json.worker.js.map

{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/monaco-editor/esm/vs/base/common/platform.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/standalone/promise-polyfill/polyfill.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-uri/index.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/errors.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/types.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/arrays.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/diff/diff.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/iterator.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/uri.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/position.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/range.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/strings.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/diff/diffComputer.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/uint.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/model/wordHelper.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/modes/linkComputer.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/functional.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/linkedList.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/event.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/cancellation.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/keyCodes.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/selection.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/core/token.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js","webpack:///./node_modules/monaco-editor/esm/vs/editor/editor.worker.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-languageserver-types/main.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/parser.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/scanner.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/format.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/main.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/jsonLanguageTypes.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/objects.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/fillers/vscode-nls.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/parser/jsonParser.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/json.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/strings.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonCompletion.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonHover.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonSchemaService.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonValidation.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/utils/colors.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonDocumentSymbols.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/configuration.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/jsonWorker.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonFolding.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/services/jsonSelectionRanges.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-json-languageservice/jsonLanguageService.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/json.worker.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","process","global","__webpack_exports__","isWindows","isWeb","globals","LANGUAGE_DEFAULT","_isWindows","_isMacintosh","_isLinux","_isNative","_isWeb","_locale","undefined","isElectronRenderer","versions","electron","type","navigator","platform","rawNlsConfig","NODE_ENV","BASE_URL","nlsConfig","JSON","parse","resolved","availableLanguages","locale","_translationsConfigFile","e","userAgent","indexOf","language","_globals","self","nextTick","fn","setTimeout","arch","execPath","title","pid","browser","env","argv","binding","Error","path","cwd","chdir","dir","resolve","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","factory","this","finallyConstructor","callback","constructor","then","reason","reject","setTimeoutFunc","noop","thisArg","apply","arguments","Promise","TypeError","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","cb","onFulfilled","onRejected","ret","promise","push","newValue","finale","length","_unhandledRejectionFn","len","Handler","done","ex","prom","all","arr","args","Array","slice","remaining","res","val","race","values","setImmediate","err","console","warn","globalNS","window","__extends","extendStatics","setPrototypeOf","__proto__","b","__","_schemePattern","_singleSlashStart","_doubleSlashStart","_validateUri","scheme","test","authority","_referenceResolution","_slash","_empty","_regexp","URI","schemeOrData","query","fragment","isUri","thing","_makeFsPath","configurable","with","change","_URI","match","exec","decodeURIComponent","file","replace","idx","substring","from","components","toString","skipEncoding","_asFormatted","toJSON","revive","data","result","_fsPath","fsPath","_formatted","external","_a","_super","_this","$mid","encodeTable","encodeURIComponentFast","uriComponent","allowSlash","nativeEncodePos","pos","code","charCodeAt","encodeURIComponent","charAt","substr","escaped","encodeURIComponentMinimal","uri","toLowerCase","encoder","userinfo","String","fromCharCode","g","Function","normalizeArray","parts","allowAboveRoot","up","last","splice","unshift","splitPathRe","splitPath","filename","filter","xs","f","resolvedPath","resolvedAbsolute","split","join","normalize","isAbsolute","trailingSlash","paths","index","relative","to","trim","start","end","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","root","basename","ext","extname","str","ErrorHandler","listeners","unexpectedErrorHandler","stack","message","emit","forEach","listener","onUnexpectedError","onUnexpectedExternalError","errorHandler","isPromiseCanceledError","transformErrorForSerialization","error","name_1","stacktrace","$isError","canceledName","illegalArgument","lifecycle_dispose","first","rest","_i","isArray","dispose","combinedDisposable","disposables","toDisposable","Disposable","_toDispose","_lifecycle_disposable_isDisposed","_register","None","freeze","ImmortalReference","getAllPropertyNames","obj","proto","getPrototypeOf","getOwnPropertyNames","INITIALIZE","simpleWorker_SimpleWorkerProtocol","SimpleWorkerProtocol","handler","_workerId","_handler","_lastSentReq","_pendingReplies","setWorkerId","workerId","sendMessage","method","req","_send","vsWorker","handleMessage","serializedMessage","_handleMessage","msg","seq","replyMessage","reply","requestMessage","detail","strMsg","stringify","simpleWorker_SimpleWorkerServer","SimpleWorkerClient","workerFactory","lazyProxyReject","_worker","_protocol","postMessage","getId","loaderConfiguration","require","getConfig","requirejs","contexts","_","config","_onModuleLoaded","_lazyProxy","availableMethods","proxy","availableMethods_1","methodName","createProxyMethod","proxyMethodRequest","_onError","_request","getProxyObject","info","SimpleWorkerServer","postSerializedMessage","requestHandler","_requestHandler","onmessage","initialize","loaderConfig","methods","prop","baseUrl","vs","catchError","handlerModule","_b","mergeSort","compare","_sort","_merge","a","lo","mid","hi","aux","leftIdx","rightIdx","DiffChange","originalStart","originalLength","modifiedStart","modifiedLength","getOriginalEnd","getModifiedEnd","createStringSequence","getLength","getElementAtIndex","stringDiff","original","modified","pretty","diff_LcsDiff","ComputeDiff","Iterator","Debug","Assert","condition","MyArray","Copy","sourceArray","sourceIndex","destinationArray","destinationIndex","MaxDifferencesHistory","diff_DiffChangeHelper","DiffChangeHelper","m_changes","m_originalStart","Number","MAX_VALUE","m_modifiedStart","m_originalCount","m_modifiedCount","MarkNextChange","AddOriginalElement","originalIndex","modifiedIndex","AddModifiedElement","getChanges","getReverseChanges","reverse","LcsDiff","originalSequence","newSequence","continueProcessingPredicate","OriginalSequence","ModifiedSequence","ContinueProcessingPredicate","m_forwardHistory","m_reverseHistory","ElementsAreEqual","newIndex","OriginalElementsAreEqual","index1","index2","ModifiedElementsAreEqual","_ComputeDiff","originalEnd","modifiedEnd","quitEarlyArr","changes","ComputeDiffRecursive","PrettifyChanges","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","WALKTRACE","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","diagonal","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","MIN_VALUE","historyIndex","originalStartPoint","modifiedStartPoint","lastForwardChange","max","numDifferences","tempOriginalIndex","maxDifferences","numDiagonals","delta","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","abs","matchLengthOfLongest","temp","originalStop","modifiedStop","checkOriginal","checkModified","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","score","_OriginalIsBoundary","element","_OriginalRegionIsBoundary","_ModifiedIsBoundary","_ModifiedRegionIsBoundary","originalScore","modifiedScore","left","right","diagonalBaseIndex","diagonalsBelow","diagonalsAbove","diffEven","lowerBoundEven","upperBoundEven","iterator_extends","FIN","next","empty","fromArray","array","elements","map","iterator","collect","uri_a","ArrayIterator","items","current","uri_extends","ArrayNavigator","previous","parent","MappedIterator","_throwOnMissingSchema","_strict","uri_URI","Position","lineNumber","column","newLineNumber","newColumn","deltaLineNumber","deltaColumn","equals","other","isBefore","isBeforeOrEqual","aLineNumber","bLineNumber","aColumn","bColumn","clone","lift","isIPosition","range_Range","Range","startLineNumber","startColumn","endLineNumber","endColumn","isEmpty","range","containsPosition","position","containsRange","otherRange","plusRange","intersectRanges","resultStartLineNumber","resultStartColumn","resultEndLineNumber","resultEndColumn","otherStartLineNumber","otherStartColumn","otherEndLineNumber","otherEndColumn","equalsRange","getEndPosition","getStartPosition","setEndPosition","setStartPosition","collapseToStart","fromPositions","isIRange","areIntersectingOrTouching","areIntersecting","compareRangesUsingStarts","aStartLineNumber","bStartLineNumber","aStartColumn","bStartColumn","aEndLineNumber","bEndLineNumber","aEndColumn","bEndColumn","aExists","bExists","compareRangesUsingEnds","spansMultipleLines","firstNonWhitespaceIndex","chCode","lastNonWhitespaceIndex","startIndex","MAXIMUM_RUN_TIME","MINIMUM_MATCHING_CHARACTER_LENGTH","computeDiff","modifiedSequence","diffAlgo","diffComputer_LineMarkerSequence","LineMarkerSequence","lines","startColumns","endColumns","length_1","_getFirstNonBlankColumn","_getLastNonBlankColumn","_lines","_startColumns","_endColumns","getStartLineNumber","getEndLineNumber","txt","defaultValue","getCharSequence","shouldIgnoreTrimWhitespace","endIndex","charCodes","lineNumbers","columns","lineContent","col","CharSequence","_charCodes","_lineNumbers","_columns","getStartColumn","getEndColumn","CharChange","originalStartLineNumber","originalStartColumn","originalEndLineNumber","originalEndColumn","modifiedStartLineNumber","modifiedStartColumn","modifiedEndLineNumber","modifiedEndColumn","createFromDiffChange","diffChange","originalCharSequence","modifiedCharSequence","postProcessCharChanges","rawChanges","currChange","originalMatchingLength","modifiedMatchingLength","matchingLength","LineChange","charChanges","createFromDiffResult","originalLineSequence","modifiedLineSequence","shouldComputeCharChanges","shouldPostProcessCharChanges","length_2","DiffComputer","originalLines","modifiedLines","opts","shouldMakePrettyDiff","maximumRunTimeMs","computationStartTime","Date","getTime","_continueProcessingPredicate","lineChanges","length_3","originalLineIndex","modifiedLineIndex","nextChange","originalLine","modifiedLine","originalChar","modifiedChar","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","now","Uint8Matrix","rows","cols","Uint8Array","_data","row","set","toUint8","v","toUint32","PrefixSumIndexOfResult","remainder","prefixSumComputer_PrefixSumComputer","PrefixSumComputer","prefixSum","Uint32Array","prefixSumValidIndex","Int32Array","getCount","insertValues","insertIndex","oldValues","oldPrefixSum","insertValuesLen","subarray","changeValue","removeValues","cnt","maxCnt","getTotalValue","_getAccumulatedValue","getAccumulatedValue","getIndexOf","accumulatedValue","floor","low","high","midStop","midStart","mirrorTextModel_MirrorTextModel","PrefixSumComputerWithCache","_cacheAccumulatedValueStart","_cache","_actual","_bustCache","cacheIndex","warmUpCache","accumulatedValueStart","accumulatedValueEnd","newCache","MirrorTextModel","eol","versionId","_uri","_eol","_versionId","_lineStarts","getText","onEvents","changes_1","_acceptDeleteRange","_acceptInsertText","text","_ensureLineStarts","eolLength","linesLength","lineStartValues","_setLineText","lineIndex","insertText","insertLines","newLengths","USUAL_WORD_SEPARATORS","createWordRegExp","allowInWords","source","USUAL_WORD_SEPARATORS_1","RegExp","DEFAULT_WORD_REGEXP","ensureValidWordDefinition","wordDefinition","flags","ignoreCase","multiline","unicode","lastIndex","getWordAtPosFast","textOffset","lastIndexOf","matchIndex","word","getWordAtPosSlow","getWordAtText","characterClassifier_CharacterClassifier","CharacterClassifier","_defaultValue","_asciiMap","_createAsciiMap","_map","Map","asciiMap","charCode","linkComputer_StateMachine","CharacterSet","add","has","StateMachine","edges","maxCharCode","maxState","states","_states","_maxCharCode","nextState","currentState","_stateMachine","getStateMachine","_classifier","getClassifier","FORCE_TERMINATION_CHARACTERS","CANNOT_END_WITH_CHARACTERS","LinkComputer","_createLink","classifier","line","linkBeginIndex","linkEndIndex","lastIncludedCharIndex","chClass","charCodeBeforeLink","lastCharCodeInLink","url","computeLinks","model","stateMachine","lineCount","getLineCount","getLineContent","j","linkBeginChCode","state","hasOpenParens","hasOpenSquareBracket","hasOpenCurlyBracket","resetStateMachine","BasicInplaceReplace","_defaultValueSet","navigateValueSet","range1","text1","range2","text2","doNavigateValueSet","numberResult","numberReplace","textReplace","precision","pow","n1","n2","parseFloat","isNaN","valueSetsReplace","valueSets","valueSetReplace","valueSet","INSTANCE","functional_once","didCall","event_Event","Node","linkedList_LinkedList","LinkedList","_size","_first","_insert","atTheEnd","newNode","oldLast","_last","prev","oldFirst","_remove","shift","node","candidate","anchor","Event","_disposable","once","event","thisArgs","didFire","snapshot","each","signal","any","events","reduce","merge","initial","output","emitter","event_Emitter","onFirstListenerAdd","fire","onLastListenerRemove","debounce","delay","leading","leakWarningThreshold","subscription","numDebouncedCalls","cur","clearTimeout","_output","stopwatch","latch","cache","firstCall","shouldEmit","buffer","_buffer","flush","onFirstListenerDidAdd","echo","onListenerDidAdd","ChainableEvent","on","chain","fromNodeEventEmitter","eventName","id","removeListener","fromPromise","toPromise","cancellation_CancellationToken","_globalLeakWarningThreshold","LeakageMonitor","customThreshold","random","_warnCountdown","_stacks","clear","check","listenerCount","threshold","count","topStack_1","topCount_1","Emitter","options","_disposed","_options","_leakageMon","_event","_listeners","firstListener","removeMonitor","remove","size","_noop","hasListeners","_deliveryQueue","iter","event_1","shortcutEvent","EventMultiplexer","hook","unhook","EventBufferer","buffers","wrapEvent","bufferEvents","pop","Relay","listening","inputEvent","inputEventListener","context","CancellationToken","isCancellationToken","Cancelled","cancellation_MutableToken","isCancellationRequested","onCancellationRequested","KeyCodeUtils","MutableToken","_isCancelled","_emitter","cancel","CancellationTokenSource","_token","KeyCodeStrMap","_keyCodeToStr","_strToKeyCode","define","keyCode","keyCodeToStr","strToKeyCode","uiMap","userSettingsUSMap","userSettingsGeneralMap","KeyChord","firstPart","secondPart","chordPart","uiLabel","usUserSettingsLabel","generalUserSettingsLabel","fromString","toUserSettingsUS","toUserSettingsGeneral","fromUserSettings","SimpleKeybinding","ctrlKey","shiftKey","altKey","metaKey","isModifierKey","toChord","keyCodes_ChordKeybinding","isDuplicateModifierCase","MarkerTag","MarkerSeverity","KeyCode","SelectionDirection","ScrollbarVisibility","OverviewRulerLane","EndOfLinePreference","DefaultEndOfLine","EndOfLineSequence","TrackedRangeStickiness","ScrollType","CursorChangeReason","RenderMinimap","WrappingIndent","TextEditorCursorBlinkingStyle","TextEditorCursorStyle","RenderLineNumbersType","ContentWidgetPositionPreference","OverlayWidgetPositionPreference","MouseTargetType","IndentAction","CompletionItemKind","CompletionItemInsertTextRule","CompletionTriggerKind","SignatureHelpTriggerKind","DocumentHighlightKind","SymbolKind","ChordKeybinding","selection_extends","ResolvedKeybindingPart","kbLabel","kbAriaLabel","keyLabel","keyAriaLabel","ResolvedKeybinding","selection_Selection","Selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","equalsSelection","selectionsEqual","getDirection","getPosition","liftSelection","sel","selectionsArrEqual","isISelection","createWithDirection","direction","Token","offset","TokenizationResult","tokens","endState","TokenizationResult2","standaloneBase_KeyMod","KeyMod","chord","CtrlCmd","Shift","Alt","WinCtrl","createMonacoBaseAPI","editor","languages","Uri","editorSimpleWorker_extends","editorSimpleWorker_MirrorModel","MirrorModel","getValue","getLinesContent","getWordAtPosition","wordAtText","getWordUntilPosition","wordAtPosition","createWordIterator","lineText","wordRangesIdx","wordRanges","_wordenize","getLineWords","content","ranges","words","ranges_1","getValueInRange","_validateRange","lineEnding","startLineIndex","endLineIndex","resultLines","offsetAt","_validatePosition","positionAt","out","lineLength","hasChanged","maxCharacter","editorSimpleWorker_BaseEditorSimpleWorker","BaseEditorSimpleWorker","foreignModuleFactory","_foreignModuleFactory","_foreignModule","originalUrl","modifiedUrl","ignoreTrimWhitespace","_getModel","diffComputer","identical","_modelsAreIdentical","originalLineCount","modifiedLineCount","computeMoreMinimalEdits","modelUrl","edits","lastEol","aRng","bRng","edits_1","_diffLimit","editOffset","newEdit","textualSuggest","wordDef","wordDefFlags","suggestions","wordDefRegExp","currentWord","seen","_suggestionsLimit","kind","label","computeWordRanges","words_1","selectionText","wordRange","loadForeignModule","createData","ctx","getMirrorModels","_getModels","fmr","editorSimpleWorker_EditorSimpleWorkerImpl","EditorSimpleWorkerImpl","_models","keys","acceptNewModel","EOL","acceptModelChanged","strURL","acceptRemovedModel","importScripts","monaco","main_Position","main_Range","Location","LocationLink","Color","ColorInformation","ColorPresentation","FoldingRangeKind","FoldingRange","DiagnosticRelatedInformation","DiagnosticSeverity","Diagnostic","Command","TextEdit","TextDocumentEdit","CreateFile","RenameFile","DeleteFile","WorkspaceEdit","initialized","foreignModule","editorWorker","simpleWorker","character","is","Is","objectLiteral","number","one","two","three","four","defined","string","targetUri","targetRange","targetSelectionRange","originSelectionRange","red","green","blue","alpha","color","textEdit","additionalTextEdits","typedArray","startLine","endLine","startCharacter","endCharacter","location","Warning","Information","Hint","severity","relatedInformation","command","newText","insert","del","textDocument","VersionedTextDocumentIdentifier","overwrite","ignoreIfExists","boolean","oldUri","newUri","recursive","ignoreIfNotExists","documentChanges","every","TextDocumentIdentifier","TextDocumentItem","MarkupKind","MarkupContent","main_CompletionItemKind","InsertTextFormat","CompletionItem","CompletionList","MarkedString","Hover","ParameterInformation","SignatureInformation","main_DocumentHighlightKind","DocumentHighlight","main_SymbolKind","SymbolInformation","TextEditChangeImpl","delete","edit","WorkspaceChange","workspaceEdit","_textEditChanges","_workspaceEdit","textEditChange","getTextEditChange","textDocumentEdit","createFile","checkDocumentChanges","renameFile","deleteFile","version","languageId","PlainText","Markdown","Text","Method","Constructor","Field","Variable","Class","Interface","Module","Property","Unit","Value","Enum","Keyword","Snippet","File","Reference","Folder","EnumMember","Constant","Struct","Operator","TypeParameter","isIncomplete","fromPlainText","plainText","contents","documentation","parameters","Read","Write","Namespace","Package","Boolean","Key","Null","containerName","CodeActionKind","CodeActionContext","CodeAction","CodeLens","FormattingOptions","DocumentSymbol","selectionRange","children","deprecated","QuickFix","Refactor","RefactorExtract","RefactorInline","RefactorRewrite","Source","SourceOrganizeImports","diagnostics","only","commandOrEdit","tabSize","insertSpaces","DocumentLink","target","TextDocument","TextDocumentSaveReason","FullTextDocument","func","applyEdits","document","sortedEdits","diff","lastModifiedOffset","startOffset","endOffset","Manual","AfterDelay","FocusOut","ParseOptions","_languageId","_version","_content","_lineOffsets","update","getLineOffsets","lineOffsets","isLineStart","ch","lineOffset","nextLineOffset","createScanner","ignoreTrivia","tokenOffset","token","scanError","scanHexDigits","exact","digits","setPosition","newPosition","scanNumber","isDigit","scanString","isLineBreak","ch_1","scanNext","isWhiteSpace","safeLength","commentClosed","isUnknownContentCharacter","scanNextNonTrivia","scan","getToken","getTokenValue","getTokenOffset","getTokenLength","getTokenError","format_format","documentText","initialIndentLevel","formatText","formatTextStart","rangeStart","rangeEnd","isEOL","computeIndentLevel","indentValue","getEOL","lineBreak","indentLevel","format_repeat","scanner","hasError","newLineAndIndent","editOperations","addEdit","firstToken","firstTokenStart","initialIndent","firstTokenEnd","secondToken","replaceContent","commentTokenStart","secondTokenStart","nChars","errors","DEFAULT","currentProperty","currentParent","previousParents","onValue","visitor","onObjectBegin","onObjectProperty","onObjectEnd","onArrayBegin","onArrayEnd","onLiteralValue","onError","visit","getNodePath","getNodeValue","valueNode","contains","includeRightBound","findNodeAtOffset","item","_scanner","toNoArgVisit","visitFunction","toOneArgVisit","arg","onSeparator","onComment","disallowComments","allowTrailingComma","handleError","skipUntilAfter","skipUntil","parseString","isValue","parseLiteral","parseProperty","parseValue","parseObject","needsComma","parseArray","SelectionRangeKind","ErrorCode","jsonLanguageTypes_ClientCapabilities","main_createScanner","main_parse","main_findNodeAtOffset","main_getNodePath","main_getNodeValue","main_format","objects_equals","oneKeys","sort","otherKeys","objects_isNumber","isDefined","objects_isBoolean","objects_isString","vscode_nls_format","localize","loadMessageBundle","ClientCapabilities","LATEST","completion","completionItem","documentationFormat","EnumMatch","jsonParser_extends","jsonParser_localize","colorHexPattern","emailPattern","ASTNodeImpl","NullASTNodeImpl","BooleanASTNodeImpl","boolValue","ArrayASTNodeImpl","NumberASTNodeImpl","isInteger","NaN","StringASTNodeImpl","PropertyASTNodeImpl","colonOffset","keyNode","ObjectASTNodeImpl","properties","asSchema","schema","not","SchemaCollector","focusOffset","exclude","schemas","include","jsonParser_contains","newSub","NoOpSchemaCollector","instance","jsonParser_ValidationResult","ValidationResult","problems","propertiesMatches","propertiesValueMatches","primaryValueMatches","enumValueMatch","enumValues","hasProblems","mergeAll","validationResults","validationResults_1","validationResult","mergeEnumValues","EnumValueMismatch","mergePropertyMatch","propertyValidationResult","newJSONDocument","jsonParser_JSONDocument","jsonParser_getNodeValue","jsonParser_getNodePath","JSONDocument","syntaxErrors","comments","getNodeFromOffset","doVisit_1","ctn","validate","getMatchingSchemas","matchingSchemas","_validateObjectNode","_validateArrayNode","_validateStringNode","_validateNumberNode","_validateNode","matchesType","some","errorMessage","allOf","subSchemaRef","notSchema","subValidationResult","subMatchingSchemas","_c","ms","inverted","testAlternatives","alternatives","maxOneMatch","matches","bestMatch","alternatives_1","subSchema","compareResult","anyOf","oneOf","testBranch","testCondition","ifSchema","thenSchema","elseSchema","if","else","enum","_d","_e","const","deprecationMessage","getExclusiveLimit","limit","exclusive","getLimit","multipleOf","exclusiveMinimum","minimum","exclusiveMaximum","maximum","minLength","maxLength","pattern","regex","patternErrorMessage","format","vscode_uri","subSchemas","itemValidationResult","additionalItems","itemSchema","containsSchema","doesContain","minItems","maxItems","uniqueItems","values_1","duplicates","seenKeys","unprocessedProperties","propertyNode","required","propertyName","propertyProcessed","propertySchema","child","patternProperties","_f","_g","propertyPattern","_h","_j","additionalProperties","_k","unprocessedProperties_1","_l","unprocessedProperties_2","maxProperties","minProperties","dependencies","_m","_o","propertyDep","_p","propertyDep_1","requiredProp","propertyNames","_q","_r","jsonParser_parse","lastProblemOffset","commentRanges","collectComments","_scanNext","token_1","_checkScanError","_errorAtRange","_error","_finalize","token_2","InvalidUnicode","InvalidEscapeCharacter","UnexpectedEndOfNumber","UnexpectedEndOfComment","UnexpectedEndOfString","InvalidCharacter","_parseArray","ValueExpected","commaOffset","TrailingComma","CommaExpected","_parseValue","CommaOrCloseBacketExpected","_parseProperty","keysSeen","_parseString","Undefined","DuplicateKey","ColonExpected","_parseObject","PropertyExpected","CommaOrCloseBraceExpected","_parseNumber","tokenValue","numberValue","_parseLiteral","_root","stringifyObject","indent","stringifyLiteral","newIndent","strings_startsWith","haystack","needle","strings_endsWith","strings_convertSimple2RegExpPattern","jsonCompletion_localize","jsonCompletion_JSONCompletion","JSONCompletion","schemaService","contributions","promiseConstructor","clientCapabilities","templateVarIdCounter","resolveCompletion","resolver","doComplete","doc","isInComment","getCurrentWord","overwriteRange","overwriteStart","proposed","collector","suggestion","existing","setAsIncomplete","log","getNumberOfProposals","getSchemaForResource","collectionPromises","addValue","currentKey","separatorAfter_1","evaluateSeparatorAfter","getPropertyCompletions","getSchemaLessPropertyCompletions","location_1","contribution","collectPromise","collectPropertyCompletions","getLabelForValue","getInsertTextForProperty","insertTextFormat","types","getValueCompletions","getSchemaLessValueCompletions","getContributedValueCompletions","offsetForSeparator","separatorAfter","addFillerValueCompletions","schemaProperties_1","doNotSuggest","proposal","sanitizeLabel","filterText","getFilterTextForValue","fromMarkup","markdownDescription","description","collectCompletionsForSimilarObject","getInsertTextForValue","parentKey_1","getSuggestionKind","collectSuggestionsForValues","getLabelTextForMatchingNode","getInsertTextForMatchingNode","addBooleanValueCompletion","parentKey_2","addDollarSchemaCompletions","parentKey_3","parentKey","valueNode_1","separatorAfter_2","findItemAtOffset","addSchemaValueCompletions","addNullValueCompletion","parentKey_4","location_2","collectValueCompletions","collectDefaultCompletions","addEnumValueCompletions","addDefaultValueCompletions","collectTypes","arrayDepth","hasProposals","default","examples","example","defaultSnippets","body","getInsertTextForSnippetValue","getFilterTextForSnippetValue","getLabelForSnippetValue","bodyText","prefix","suffix","enm","markdownEnumDescriptions","doesSupportMarkdown","enumDescriptions","getInsertTextForGuessedValue","schemaIds","getRegisteredSchemaIds","schemaId","getInsertTextForPlainText","replacer","snippetValue","propertyText","resultText","nValueProposals","markupString","supportsMarkdown","jsonHover_JSONHover","JSONHover","doHover","hoverRangeNode","hoverRange","createHover","getInfoContribution","htmlContent","title_1","markdownDescription_1","markdownEnumValueDescription_1","enumValue_1","toMarkdown","plain","jsonSchemaService_localize","jsonSchemaService_FilePatternAssociation","FilePatternAssociation","patternRegExp","addSchema","matchesPattern","fileName","getSchemas","SchemaHandle","service","unresolvedSchemaContent","unresolvedSchema","UnresolvedSchema","getUnresolvedSchema","loadSchema","getResolvedSchema","resolvedSchema","unresolved","resolveSchemaContent","clearSchema","jsonSchemaService_ResolvedSchema","ResolvedSchema","getSection","getSectionRecursive","parseInt","jsonSchemaService_JSONSchemaService","JSONSchemaService","requestService","contextService","callOnDispose","contributionSchemas","contributionAssociations","schemasById","filePatternAssociations","filePatternAssociationById","registeredSchemasIds","onResourceChange","hasChanges","normalizeId","toWalk","curr","setSchemaContributions","schemaContributions","normalizedId","addSchemaHandle","schemaAssociations","associations","fpa","getOrAddFilePatternAssociation","associations_1","schemaHandle","getOrAddSchemaHandle","registerExternalSchema","filePatterns","filePatterns_1","clearExternalSchemas","toDisplayString","schemaContent","jsonErrors","errorSplit","schemaToResolve","schemaURL","resolveErrors","findSection","part","sourceRoot","sourceURI","section","resolveExternalLink","linkPath","parentSchemaURL","parentSchemaDependencies","resolveRelativePath","referencedHandle","loc","resolveRefs","parentSchema","openPromises","collectEntries","entries","entries_1","entry","collectMapEntries","maps","maps_1","collectArrayEntries","arrays","arrays_1","array_1","handleRef","seenRefs","$ref","ref","segments","definitions","resource","schemaProperties","schemeId","createCombinedSchema","combinedSchemaId","combinedSchema","jsonValidation_localize","jsonValidation_JSONValidation","JSONValidation","jsonSchemaService","validationEnabled","configure","raw","commentSeverity","allowComments","doValidation","jsonDocument","documentSettings","added","addProblem","problem","signature","getDiagnostics","trailingCommaSeverity","toDiagnosticSeverity","trailingCommas","astRoot","SchemaResolveError","semanticErrors","schemaAllowsComments","message_1","CommentNotPermitted","idCounter","schemaRef","severityLevel","Digit0","Digit9","A","colors_a","colors_f","hexDigit","colorFromHex","jsonDocumentSymbols_JSONDocumentSymbols","JSONDocumentSymbols","findDocumentSymbols","resourceString","result_1","getRange","collectOutlineEntries","childContainerName","getKeyLabel","getSymbolKind","findDocumentSymbols2","result_2","nodeType","findDocumentColors","visitedNode","matchingSchemas_1","nodeId","getColorPresentations","red256","round","green256","blue256","toTwoDigitHex","defaultSchemaRequestService","configuration_localize","http://json-schema.org/draft-04/schema#","$schema","schemaArray","positiveInteger","positiveIntegerDefault0","simpleTypes","stringArray","http://json-schema.org/draft-07/schema#","nonNegativeInteger","nonNegativeIntegerDefault0","$id","$comment","readOnly","contentMediaType","contentEncoding","descriptions","schemaName","configuration_schema","configuration_property","propertyObject","getFoldingRanges","nestingLevels","prevStart","addRange","Comment","Region","rangeLimit","counts","nestingLevels_1","level","maxLevel","getSelectionRanges","positions","getSelectionRange","cStart","cEnd","newRange","afterCommaOffset","getOffsetAfterNextToken","Declaration","expectedToken","getLanguageService","params","schemaRequestService","workspaceContext","jsonCompletion","jsonHover","jsonDocumentSymbols","jsonValidation","settings","fileMatch","resetSchema","parseJSONDocument","findColorSymbols","fetch","response","PromiseAdapter","executor","wrapped","onfulfilled","onrejected","thenable","getWrapped","jsonWorker_JSONWorker","JSONWorker","_ctx","_languageSettings","languageSettings","_languageService","enableSchemaRequest","_getTextDocument","textEdits","symbols","stylesheet","colorSymbols","colorPresentations","provideFoldingRanges","models","models_1"],"mappings":"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","file":"json.worker.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"f19f\");\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var LANGUAGE_DEFAULT = 'en';\nvar _isWindows = false;\nvar _isMacintosh = false;\nvar _isLinux = false;\nvar _isNative = false;\nvar _isWeb = false;\nvar _locale = undefined;\nvar _language = LANGUAGE_DEFAULT;\nvar _translationsConfigFile = undefined;\nvar isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\n// OS detection\nif (typeof navigator === 'object' && !isElectronRenderer) {\n    var userAgent = navigator.userAgent;\n    _isWindows = userAgent.indexOf('Windows') >= 0;\n    _isMacintosh = userAgent.indexOf('Macintosh') >= 0;\n    _isLinux = userAgent.indexOf('Linux') >= 0;\n    _isWeb = true;\n    _locale = navigator.language;\n    _language = _locale;\n}\nelse if (typeof process === 'object') {\n    _isWindows = (process.platform === 'win32');\n    _isMacintosh = (process.platform === 'darwin');\n    _isLinux = (process.platform === 'linux');\n    _locale = LANGUAGE_DEFAULT;\n    _language = LANGUAGE_DEFAULT;\n    var rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];\n    if (rawNlsConfig) {\n        try {\n            var nlsConfig = JSON.parse(rawNlsConfig);\n            var resolved = nlsConfig.availableLanguages['*'];\n            _locale = nlsConfig.locale;\n            // VSCode's default language is 'en'\n            _language = resolved ? resolved : LANGUAGE_DEFAULT;\n            _translationsConfigFile = nlsConfig._translationsConfigFile;\n        }\n        catch (e) {\n        }\n    }\n    _isNative = true;\n}\nvar _platform = 0 /* Web */;\nif (_isNative) {\n    if (_isMacintosh) {\n        _platform = 1 /* Mac */;\n    }\n    else if (_isWindows) {\n        _platform = 3 /* Windows */;\n    }\n    else if (_isLinux) {\n        _platform = 2 /* Linux */;\n    }\n}\nexport var isWindows = _isWindows;\nexport var isMacintosh = _isMacintosh;\nexport var isLinux = _isLinux;\nexport var isNative = _isNative;\nexport var isWeb = _isWeb;\nvar _globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});\nexport var globals = _globals;\nvar _setImmediate = null;\nexport function setImmediate(callback) {\n    if (_setImmediate === null) {\n        if (globals.setImmediate) {\n            _setImmediate = globals.setImmediate.bind(globals);\n        }\n        else if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {\n            _setImmediate = process.nextTick.bind(process);\n        }\n        else {\n            _setImmediate = globals.setTimeout.bind(globals);\n        }\n    }\n    return _setImmediate(callback);\n}\nexport var OS = (_isMacintosh ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));\n","exports.nextTick = function nextTick(fn) {\n\tsetTimeout(fn, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","/*!\nCopyright (c) 2014 Taylor Hakes\nCopyright (c) 2014 Forbes Lindesay\n */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory() :\n\t\ttypeof define === 'function' && define.amd ? define(factory) :\n\t\t\t(factory());\n}(this, (function () {\n\t'use strict';\n\n\t/**\n\t * @this {Promise}\n\t */\n\tfunction finallyConstructor(callback) {\n\t\tvar constructor = this.constructor;\n\t\treturn this.then(\n\t\t\tfunction (value) {\n\t\t\t\treturn constructor.resolve(callback()).then(function () {\n\t\t\t\t\treturn value;\n\t\t\t\t});\n\t\t\t},\n\t\t\tfunction (reason) {\n\t\t\t\treturn constructor.resolve(callback()).then(function () {\n\t\t\t\t\treturn constructor.reject(reason);\n\t\t\t\t});\n\t\t\t}\n\t\t);\n\t}\n\n\t// Store setTimeout reference so promise-polyfill will be unaffected by\n\t// other code modifying setTimeout (like sinon.useFakeTimers())\n\tvar setTimeoutFunc = setTimeout;\n\n\tfunction noop() { }\n\n\t// Polyfill for Function.prototype.bind\n\tfunction bind(fn, thisArg) {\n\t\treturn function () {\n\t\t\tfn.apply(thisArg, arguments);\n\t\t};\n\t}\n\n\t/**\n\t * @constructor\n\t * @param {Function} fn\n\t */\n\tfunction Promise(fn) {\n\t\tif (!(this instanceof Promise))\n\t\t\tthrow new TypeError('Promises must be constructed via new');\n\t\tif (typeof fn !== 'function') throw new TypeError('not a function');\n\t\t/** @type {!number} */\n\t\tthis._state = 0;\n\t\t/** @type {!boolean} */\n\t\tthis._handled = false;\n\t\t/** @type {Promise|undefined} */\n\t\tthis._value = undefined;\n\t\t/** @type {!Array<!Function>} */\n\t\tthis._deferreds = [];\n\n\t\tdoResolve(fn, this);\n\t}\n\n\tfunction handle(self, deferred) {\n\t\twhile (self._state === 3) {\n\t\t\tself = self._value;\n\t\t}\n\t\tif (self._state === 0) {\n\t\t\tself._deferreds.push(deferred);\n\t\t\treturn;\n\t\t}\n\t\tself._handled = true;\n\t\tPromise._immediateFn(function () {\n\t\t\tvar cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n\t\t\tif (cb === null) {\n\t\t\t\t(self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tvar ret;\n\t\t\ttry {\n\t\t\t\tret = cb(self._value);\n\t\t\t} catch (e) {\n\t\t\t\treject(deferred.promise, e);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresolve(deferred.promise, ret);\n\t\t});\n\t}\n\n\tfunction resolve(self, newValue) {\n\t\ttry {\n\t\t\t// Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n\t\t\tif (newValue === self)\n\t\t\t\tthrow new TypeError('A promise cannot be resolved with itself.');\n\t\t\tif (\n\t\t\t\tnewValue &&\n\t\t\t\t(typeof newValue === 'object' || typeof newValue === 'function')\n\t\t\t) {\n\t\t\t\tvar then = newValue.then;\n\t\t\t\tif (newValue instanceof Promise) {\n\t\t\t\t\tself._state = 3;\n\t\t\t\t\tself._value = newValue;\n\t\t\t\t\tfinale(self);\n\t\t\t\t\treturn;\n\t\t\t\t} else if (typeof then === 'function') {\n\t\t\t\t\tdoResolve(bind(then, newValue), self);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tself._state = 1;\n\t\t\tself._value = newValue;\n\t\t\tfinale(self);\n\t\t} catch (e) {\n\t\t\treject(self, e);\n\t\t}\n\t}\n\n\tfunction reject(self, newValue) {\n\t\tself._state = 2;\n\t\tself._value = newValue;\n\t\tfinale(self);\n\t}\n\n\tfunction finale(self) {\n\t\tif (self._state === 2 && self._deferreds.length === 0) {\n\t\t\tPromise._immediateFn(function () {\n\t\t\t\tif (!self._handled) {\n\t\t\t\t\tPromise._unhandledRejectionFn(self._value);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\tfor (var i = 0, len = self._deferreds.length; i < len; i++) {\n\t\t\thandle(self, self._deferreds[i]);\n\t\t}\n\t\tself._deferreds = null;\n\t}\n\n\t/**\n\t * @constructor\n\t */\n\tfunction Handler(onFulfilled, onRejected, promise) {\n\t\tthis.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n\t\tthis.onRejected = typeof onRejected === 'function' ? onRejected : null;\n\t\tthis.promise = promise;\n\t}\n\n\t/**\n\t * Take a potentially misbehaving resolver function and make sure\n\t * onFulfilled and onRejected are only called once.\n\t *\n\t * Makes no guarantees about asynchrony.\n\t */\n\tfunction doResolve(fn, self) {\n\t\tvar done = false;\n\t\ttry {\n\t\t\tfn(\n\t\t\t\tfunction (value) {\n\t\t\t\t\tif (done) return;\n\t\t\t\t\tdone = true;\n\t\t\t\t\tresolve(self, value);\n\t\t\t\t},\n\t\t\t\tfunction (reason) {\n\t\t\t\t\tif (done) return;\n\t\t\t\t\tdone = true;\n\t\t\t\t\treject(self, reason);\n\t\t\t\t}\n\t\t\t);\n\t\t} catch (ex) {\n\t\t\tif (done) return;\n\t\t\tdone = true;\n\t\t\treject(self, ex);\n\t\t}\n\t}\n\n\tPromise.prototype['catch'] = function (onRejected) {\n\t\treturn this.then(null, onRejected);\n\t};\n\n\tPromise.prototype.then = function (onFulfilled, onRejected) {\n\t\t// @ts-ignore\n\t\tvar prom = new this.constructor(noop);\n\n\t\thandle(this, new Handler(onFulfilled, onRejected, prom));\n\t\treturn prom;\n\t};\n\n\tPromise.prototype['finally'] = finallyConstructor;\n\n\tPromise.all = function (arr) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\tif (!arr || typeof arr.length === 'undefined')\n\t\t\t\tthrow new TypeError('Promise.all accepts an array');\n\t\t\tvar args = Array.prototype.slice.call(arr);\n\t\t\tif (args.length === 0) return resolve([]);\n\t\t\tvar remaining = args.length;\n\n\t\t\tfunction res(i, val) {\n\t\t\t\ttry {\n\t\t\t\t\tif (val && (typeof val === 'object' || typeof val === 'function')) {\n\t\t\t\t\t\tvar then = val.then;\n\t\t\t\t\t\tif (typeof then === 'function') {\n\t\t\t\t\t\t\tthen.call(\n\t\t\t\t\t\t\t\tval,\n\t\t\t\t\t\t\t\tfunction (val) {\n\t\t\t\t\t\t\t\t\tres(i, val);\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\treject\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\targs[i] = val;\n\t\t\t\t\tif (--remaining === 0) {\n\t\t\t\t\t\tresolve(args);\n\t\t\t\t\t}\n\t\t\t\t} catch (ex) {\n\t\t\t\t\treject(ex);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (var i = 0; i < args.length; i++) {\n\t\t\t\tres(i, args[i]);\n\t\t\t}\n\t\t});\n\t};\n\n\tPromise.resolve = function (value) {\n\t\tif (value && typeof value === 'object' && value.constructor === Promise) {\n\t\t\treturn value;\n\t\t}\n\n\t\treturn new Promise(function (resolve) {\n\t\t\tresolve(value);\n\t\t});\n\t};\n\n\tPromise.reject = function (value) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\treject(value);\n\t\t});\n\t};\n\n\tPromise.race = function (values) {\n\t\treturn new Promise(function (resolve, reject) {\n\t\t\tfor (var i = 0, len = values.length; i < len; i++) {\n\t\t\t\tvalues[i].then(resolve, reject);\n\t\t\t}\n\t\t});\n\t};\n\n\t// Use polyfill for setImmediate for performance gains\n\tPromise._immediateFn =\n\t\t(typeof setImmediate === 'function' &&\n\t\t\tfunction (fn) {\n\t\t\t\tsetImmediate(fn);\n\t\t\t}) ||\n\t\tfunction (fn) {\n\t\t\tsetTimeoutFunc(fn, 0);\n\t\t};\n\n\tPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n\t\tif (typeof console !== 'undefined' && console) {\n\t\t\tconsole.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n\t\t}\n\t};\n\n\t/** @suppress {undefinedVars} */\n\tvar globalNS = (function () {\n\t\t// the only reliable means to get the global object is\n\t\t// `Function('return this')()`\n\t\t// However, this causes CSP violations in Chrome apps.\n\t\tif (typeof self !== 'undefined') {\n\t\t\treturn self;\n\t\t}\n\t\tif (typeof window !== 'undefined') {\n\t\t\treturn window;\n\t\t}\n\t\tif (typeof global !== 'undefined') {\n\t\t\treturn global;\n\t\t}\n\t\tthrow new Error('unable to locate global object');\n\t})();\n\n\tif (!('Promise' in globalNS)) {\n\t\tglobalNS['Promise'] = Promise;\n\t} else if (!globalNS.Promise.prototype['finally']) {\n\t\tglobalNS.Promise.prototype['finally'] = finallyConstructor;\n\t}\n\n})));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar isWindows;\nif (typeof process === 'object') {\n    isWindows = process.platform === 'win32';\n}\nelse if (typeof navigator === 'object') {\n    var userAgent = navigator.userAgent;\n    isWindows = userAgent.indexOf('Windows') >= 0;\n}\n//#endregion\nvar _schemePattern = /^\\w[\\w\\d+.-]*$/;\nvar _singleSlashStart = /^\\//;\nvar _doubleSlashStart = /^\\/\\//;\nfunction _validateUri(ret) {\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n        throw new Error('[UriError]: Scheme contains illegal characters.');\n    }\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\n    // If a URI contains an authority component, then the path component\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\n    // does not contain an authority component, then the path cannot begin\n    // with two slash characters (\"//\").\n    if (ret.path) {\n        if (ret.authority) {\n            if (!_singleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character');\n            }\n        }\n        else {\n            if (_doubleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n            }\n        }\n    }\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n    // the slash-character is our 'default base' as we don't\n    // support constructing URIs relative to other URIs. This\n    // also means that we alter and potentially break paths.\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n    switch (scheme) {\n        case 'https':\n        case 'http':\n        case 'file':\n            if (!path) {\n                path = _slash;\n            }\n            else if (path[0] !== _slash) {\n                path = _slash + path;\n            }\n            break;\n    }\n    return path;\n}\nvar _empty = '';\nvar _slash = '/';\nvar _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n *       foo://example.com:8042/over/there?name=ferret#nose\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\n *        |           |            |            |        |\n *     scheme     authority       path        query   fragment\n *        |   _____________________|__\n *       / \\ /                        \\\n *       urn:example:animal:ferret:nose\n */\nvar URI = (function () {\n    /**\n     * @internal\n     */\n    function URI(schemeOrData, authority, path, query, fragment) {\n        if (typeof schemeOrData === 'object') {\n            this.scheme = schemeOrData.scheme || _empty;\n            this.authority = schemeOrData.authority || _empty;\n            this.path = schemeOrData.path || _empty;\n            this.query = schemeOrData.query || _empty;\n            this.fragment = schemeOrData.fragment || _empty;\n            // no validation because it's this URI\n            // that creates uri components.\n            // _validateUri(this);\n        }\n        else {\n            this.scheme = schemeOrData || _empty;\n            this.authority = authority || _empty;\n            this.path = _referenceResolution(this.scheme, path || _empty);\n            this.query = query || _empty;\n            this.fragment = fragment || _empty;\n            _validateUri(this);\n        }\n    }\n    URI.isUri = function (thing) {\n        if (thing instanceof URI) {\n            return true;\n        }\n        if (!thing) {\n            return false;\n        }\n        return typeof thing.authority === 'string'\n            && typeof thing.fragment === 'string'\n            && typeof thing.path === 'string'\n            && typeof thing.query === 'string'\n            && typeof thing.scheme === 'string';\n    };\n    Object.defineProperty(URI.prototype, \"fsPath\", {\n        // ---- filesystem path -----------------------\n        /**\n         * Returns a string representing the corresponding file system path of this URI.\n         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n         * platform specific path separator.\n         *\n         * * Will *not* validate the path for invalid characters and semantics.\n         * * Will *not* look at the scheme of this URI.\n         * * The result shall *not* be used for display purposes but for accessing a file on disk.\n         *\n         *\n         * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n         *\n         * ```ts\n            const u = URI.parse('file://server/c$/folder/file.txt')\n            u.authority === 'server'\n            u.path === '/shares/c$/file.txt'\n            u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n        ```\n         *\n         * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n         * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n         * with URIs that represent files on disk (`file` scheme).\n         */\n        get: function () {\n            // if (this.scheme !== 'file') {\n            // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n            // }\n            return _makeFsPath(this);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // ---- modify to new -------------------------\n    URI.prototype.with = function (change) {\n        if (!change) {\n            return this;\n        }\n        var scheme = change.scheme, authority = change.authority, path = change.path, query = change.query, fragment = change.fragment;\n        if (scheme === void 0) {\n            scheme = this.scheme;\n        }\n        else if (scheme === null) {\n            scheme = _empty;\n        }\n        if (authority === void 0) {\n            authority = this.authority;\n        }\n        else if (authority === null) {\n            authority = _empty;\n        }\n        if (path === void 0) {\n            path = this.path;\n        }\n        else if (path === null) {\n            path = _empty;\n        }\n        if (query === void 0) {\n            query = this.query;\n        }\n        else if (query === null) {\n            query = _empty;\n        }\n        if (fragment === void 0) {\n            fragment = this.fragment;\n        }\n        else if (fragment === null) {\n            fragment = _empty;\n        }\n        if (scheme === this.scheme\n            && authority === this.authority\n            && path === this.path\n            && query === this.query\n            && fragment === this.fragment) {\n            return this;\n        }\n        return new _URI(scheme, authority, path, query, fragment);\n    };\n    // ---- parse & validate ------------------------\n    /**\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\n     * `file:///usr/home`, or `scheme:with/path`.\n     *\n     * @param value A string which represents an URI (see `URI#toString`).\n     */\n    URI.parse = function (value) {\n        var match = _regexp.exec(value);\n        if (!match) {\n            return new _URI(_empty, _empty, _empty, _empty, _empty);\n        }\n        return new _URI(match[2] || _empty, decodeURIComponent(match[4] || _empty), decodeURIComponent(match[5] || _empty), decodeURIComponent(match[7] || _empty), decodeURIComponent(match[9] || _empty));\n    };\n    /**\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\n     *\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n     * `URI.parse('file://' + path)` because the path might contain characters that are\n     * interpreted (# and ?). See the following sample:\n     * ```ts\n    const good = URI.file('/coding/c#/project1');\n    good.scheme === 'file';\n    good.path === '/coding/c#/project1';\n    good.fragment === '';\n\n    const bad = URI.parse('file://' + '/coding/c#/project1');\n    bad.scheme === 'file';\n    bad.path === '/coding/c'; // path is now broken\n    bad.fragment === '/project1';\n    ```\n     *\n     * @param path A file system path (see `URI#fsPath`)\n     */\n    URI.file = function (path) {\n        var authority = _empty;\n        // normalize to fwd-slashes on windows,\n        // on other systems bwd-slashes are valid\n        // filename character, eg /f\\oo/ba\\r.txt\n        if (isWindows) {\n            path = path.replace(/\\\\/g, _slash);\n        }\n        // check for authority as used in UNC shares\n        // or use the path as given\n        if (path[0] === _slash && path[1] === _slash) {\n            var idx = path.indexOf(_slash, 2);\n            if (idx === -1) {\n                authority = path.substring(2);\n                path = _slash;\n            }\n            else {\n                authority = path.substring(2, idx);\n                path = path.substring(idx) || _slash;\n            }\n        }\n        return new _URI('file', authority, path, _empty, _empty);\n    };\n    URI.from = function (components) {\n        return new _URI(components.scheme, components.authority, components.path, components.query, components.fragment);\n    };\n    // ---- printing/externalize ---------------------------\n    /**\n     * Creates a string presentation for this URI. It's guardeed that calling\n     * `URI.parse` with the result of this function creates an URI which is equal\n     * to this URI.\n     *\n     * * The result shall *not* be used for display purposes but for externalization or transport.\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\n     * ignore the scheme-specific encoding rules.\n     *\n     * @param skipEncoding Do not encode the result, default is `false`\n     */\n    URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        return _asFormatted(this, skipEncoding);\n    };\n    URI.prototype.toJSON = function () {\n        return this;\n    };\n    URI.revive = function (data) {\n        if (!data) {\n            return data;\n        }\n        else if (data instanceof URI) {\n            return data;\n        }\n        else {\n            var result = new _URI(data);\n            result._fsPath = data.fsPath;\n            result._formatted = data.external;\n            return result;\n        }\n    };\n    return URI;\n}());\nexport default URI;\n// tslint:disable-next-line:class-name\nvar _URI = (function (_super) {\n    __extends(_URI, _super);\n    function _URI() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this._formatted = null;\n        _this._fsPath = null;\n        return _this;\n    }\n    Object.defineProperty(_URI.prototype, \"fsPath\", {\n        get: function () {\n            if (!this._fsPath) {\n                this._fsPath = _makeFsPath(this);\n            }\n            return this._fsPath;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    _URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        if (!skipEncoding) {\n            if (!this._formatted) {\n                this._formatted = _asFormatted(this, false);\n            }\n            return this._formatted;\n        }\n        else {\n            // we don't cache that\n            return _asFormatted(this, true);\n        }\n    };\n    _URI.prototype.toJSON = function () {\n        var res = {\n            $mid: 1\n        };\n        // cached state\n        if (this._fsPath) {\n            res.fsPath = this._fsPath;\n        }\n        if (this._formatted) {\n            res.external = this._formatted;\n        }\n        // uri components\n        if (this.path) {\n            res.path = this.path;\n        }\n        if (this.scheme) {\n            res.scheme = this.scheme;\n        }\n        if (this.authority) {\n            res.authority = this.authority;\n        }\n        if (this.query) {\n            res.query = this.query;\n        }\n        if (this.fragment) {\n            res.fragment = this.fragment;\n        }\n        return res;\n    };\n    return _URI;\n}(URI));\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nvar encodeTable = (_a = {},\n    _a[58 /* Colon */] = '%3A',\n    _a[47 /* Slash */] = '%2F',\n    _a[63 /* QuestionMark */] = '%3F',\n    _a[35 /* Hash */] = '%23',\n    _a[91 /* OpenSquareBracket */] = '%5B',\n    _a[93 /* CloseSquareBracket */] = '%5D',\n    _a[64 /* AtSign */] = '%40',\n    _a[33 /* ExclamationMark */] = '%21',\n    _a[36 /* DollarSign */] = '%24',\n    _a[38 /* Ampersand */] = '%26',\n    _a[39 /* SingleQuote */] = '%27',\n    _a[40 /* OpenParen */] = '%28',\n    _a[41 /* CloseParen */] = '%29',\n    _a[42 /* Asterisk */] = '%2A',\n    _a[43 /* Plus */] = '%2B',\n    _a[44 /* Comma */] = '%2C',\n    _a[59 /* Semicolon */] = '%3B',\n    _a[61 /* Equals */] = '%3D',\n    _a[32 /* Space */] = '%20',\n    _a);\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\n    var res = undefined;\n    var nativeEncodePos = -1;\n    for (var pos = 0; pos < uriComponent.length; pos++) {\n        var code = uriComponent.charCodeAt(pos);\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\n            || code === 45 /* Dash */\n            || code === 46 /* Period */\n            || code === 95 /* Underline */\n            || code === 126 /* Tilde */\n            || (allowSlash && code === 47 /* Slash */)) {\n            // check if we are delaying native encode\n            if (nativeEncodePos !== -1) {\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                nativeEncodePos = -1;\n            }\n            // check if we write into a new string (by default we try to return the param)\n            if (res !== undefined) {\n                res += uriComponent.charAt(pos);\n            }\n        }\n        else {\n            // encoding needed, we need to allocate a new string\n            if (res === undefined) {\n                res = uriComponent.substr(0, pos);\n            }\n            // check with default table first\n            var escaped = encodeTable[code];\n            if (escaped !== undefined) {\n                // check if we are delaying native encode\n                if (nativeEncodePos !== -1) {\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                    nativeEncodePos = -1;\n                }\n                // append escaped variant to result\n                res += escaped;\n            }\n            else if (nativeEncodePos === -1) {\n                // use native encode only when needed\n                nativeEncodePos = pos;\n            }\n        }\n    }\n    if (nativeEncodePos !== -1) {\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n    }\n    return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n    var res = undefined;\n    for (var pos = 0; pos < path.length; pos++) {\n        var code = path.charCodeAt(pos);\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\n            if (res === undefined) {\n                res = path.substr(0, pos);\n            }\n            res += encodeTable[code];\n        }\n        else {\n            if (res !== undefined) {\n                res += path[pos];\n            }\n        }\n    }\n    return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n * @param uri\n */\nfunction _makeFsPath(uri) {\n    var value;\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n        // unc path: file://shares/c$/far/boo\n        value = \"//\" + uri.authority + uri.path;\n    }\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\n        && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */)\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\n        // windows drive letter: file:///c:/far/boo\n        value = uri.path[1].toLowerCase() + uri.path.substr(2);\n    }\n    else {\n        // other path\n        value = uri.path;\n    }\n    if (isWindows) {\n        value = value.replace(/\\//g, '\\\\');\n    }\n    return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n    var encoder = !skipEncoding\n        ? encodeURIComponentFast\n        : encodeURIComponentMinimal;\n    var res = '';\n    var scheme = uri.scheme, authority = uri.authority, path = uri.path, query = uri.query, fragment = uri.fragment;\n    if (scheme) {\n        res += scheme;\n        res += ':';\n    }\n    if (authority || scheme === 'file') {\n        res += _slash;\n        res += _slash;\n    }\n    if (authority) {\n        var idx = authority.indexOf('@');\n        if (idx !== -1) {\n            // <user>@<auth>\n            var userinfo = authority.substr(0, idx);\n            authority = authority.substr(idx + 1);\n            idx = userinfo.indexOf(':');\n            if (idx === -1) {\n                res += encoder(userinfo, false);\n            }\n            else {\n                // <user>:<pass>@<auth>\n                res += encoder(userinfo.substr(0, idx), false);\n                res += ':';\n                res += encoder(userinfo.substr(idx + 1), false);\n            }\n            res += '@';\n        }\n        authority = authority.toLowerCase();\n        idx = authority.indexOf(':');\n        if (idx === -1) {\n            res += encoder(authority, false);\n        }\n        else {\n            // <auth>:<port>\n            res += encoder(authority.substr(0, idx), false);\n            res += authority.substr(idx);\n        }\n    }\n    if (path) {\n        // lower-case windows drive letters in /C:/fff or C:/fff\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\n            var code = path.charCodeAt(1);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = \"/\" + String.fromCharCode(code + 32) + \":\" + path.substr(3); // \"/c:\".length === 3\n            }\n        }\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\n            var code = path.charCodeAt(0);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = String.fromCharCode(code + 32) + \":\" + path.substr(2); // \"/c:\".length === 3\n            }\n        }\n        // encode the rest of the path\n        res += encoder(path, true);\n    }\n    if (query) {\n        res += '?';\n        res += encoder(query, false);\n    }\n    if (fragment) {\n        res += '#';\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\n    }\n    return res;\n}\nvar _a;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\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// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nvar splitPathRe =\n    /^(\\/?|)([\\s\\S]*?)((?:\\.{1,2}|[^\\/]+?|)(\\.[^.\\/]*|))(?:[\\/]*)$/;\nvar splitPath = function(filename) {\n  return splitPathRe.exec(filename).slice(1);\n};\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function(path) {\n  var result = splitPath(path),\n      root = result[0],\n      dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.substr(0, dir.length - 1);\n  }\n\n  return root + dir;\n};\n\n\nexports.basename = function(path, ext) {\n  var f = splitPath(path)[2];\n  // TODO: make this comparison case-insensitive on windows?\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\n\nexports.extname = function(path) {\n  return splitPath(path)[3];\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nvar ErrorHandler = /** @class */ (function () {\n    function ErrorHandler() {\n        this.listeners = [];\n        this.unexpectedErrorHandler = function (e) {\n            setTimeout(function () {\n                if (e.stack) {\n                    throw new Error(e.message + '\\n\\n' + e.stack);\n                }\n                throw e;\n            }, 0);\n        };\n    }\n    ErrorHandler.prototype.emit = function (e) {\n        this.listeners.forEach(function (listener) {\n            listener(e);\n        });\n    };\n    ErrorHandler.prototype.onUnexpectedError = function (e) {\n        this.unexpectedErrorHandler(e);\n        this.emit(e);\n    };\n    // For external errors, we don't want the listeners to be called\n    ErrorHandler.prototype.onUnexpectedExternalError = function (e) {\n        this.unexpectedErrorHandler(e);\n    };\n    return ErrorHandler;\n}());\nexport { ErrorHandler };\nexport var errorHandler = new ErrorHandler();\nexport function onUnexpectedError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedError(e);\n    }\n    return undefined;\n}\nexport function onUnexpectedExternalError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedExternalError(e);\n    }\n    return undefined;\n}\nexport function transformErrorForSerialization(error) {\n    if (error instanceof Error) {\n        var name_1 = error.name, message = error.message;\n        var stack = error.stacktrace || error.stack;\n        return {\n            $isError: true,\n            name: name_1,\n            message: message,\n            stack: stack\n        };\n    }\n    // return as is\n    return error;\n}\nvar canceledName = 'Canceled';\n/**\n * Checks if the given error is a promise in canceled state\n */\nexport function isPromiseCanceledError(error) {\n    return error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n/**\n * Returns an error that signals cancellation.\n */\nexport function canceled() {\n    var error = new Error(canceledName);\n    error.name = error.message;\n    return error;\n}\nexport function illegalArgument(name) {\n    if (name) {\n        return new Error(\"Illegal argument: \" + name);\n    }\n    else {\n        return new Error('Illegal argument');\n    }\n}\nexport function illegalState(name) {\n    if (name) {\n        return new Error(\"Illegal state: \" + name);\n    }\n    else {\n        return new Error('Illegal state');\n    }\n}\n","export function isDisposable(thing) {\n    return typeof thing.dispose === 'function'\n        && thing.dispose.length === 0;\n}\nexport function dispose(first) {\n    var rest = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        rest[_i - 1] = arguments[_i];\n    }\n    if (Array.isArray(first)) {\n        first.forEach(function (d) { return d && d.dispose(); });\n        return [];\n    }\n    else if (rest.length === 0) {\n        if (first) {\n            first.dispose();\n            return first;\n        }\n        return undefined;\n    }\n    else {\n        dispose(first);\n        dispose(rest);\n        return [];\n    }\n}\nexport function combinedDisposable(disposables) {\n    return { dispose: function () { return dispose(disposables); } };\n}\nexport function toDisposable(fn) {\n    return { dispose: function () { fn(); } };\n}\nvar Disposable = /** @class */ (function () {\n    function Disposable() {\n        this._toDispose = [];\n        this._lifecycle_disposable_isDisposed = false;\n    }\n    Disposable.prototype.dispose = function () {\n        this._lifecycle_disposable_isDisposed = true;\n        this._toDispose = dispose(this._toDispose);\n    };\n    Disposable.prototype._register = function (t) {\n        if (this._lifecycle_disposable_isDisposed) {\n            console.warn('Registering disposable on object that has already been disposed.');\n            t.dispose();\n        }\n        else {\n            this._toDispose.push(t);\n        }\n        return t;\n    };\n    Disposable.None = Object.freeze({ dispose: function () { } });\n    return Disposable;\n}());\nexport { Disposable };\nvar ImmortalReference = /** @class */ (function () {\n    function ImmortalReference(object) {\n        this.object = object;\n    }\n    ImmortalReference.prototype.dispose = function () { };\n    return ImmortalReference;\n}());\nexport { ImmortalReference };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _typeof = {\n    number: 'number',\n    string: 'string',\n    undefined: 'undefined',\n    object: 'object',\n    function: 'function'\n};\n/**\n * @returns whether the provided parameter is a JavaScript Array or not.\n */\nexport function isArray(array) {\n    if (Array.isArray) {\n        return Array.isArray(array);\n    }\n    if (array && typeof (array.length) === _typeof.number && array.constructor === Array) {\n        return true;\n    }\n    return false;\n}\n/**\n * @returns whether the provided parameter is a JavaScript String or not.\n */\nexport function isString(str) {\n    if (typeof (str) === _typeof.string || str instanceof String) {\n        return true;\n    }\n    return false;\n}\n/**\n *\n * @returns whether the provided parameter is of type `object` but **not**\n *\t`null`, an `array`, a `regexp`, nor a `date`.\n */\nexport function isObject(obj) {\n    // The method can't do a type cast since there are type (like strings) which\n    // are subclasses of any put not positvely matched by the function. Hence type\n    // narrowing results in wrong results.\n    return typeof obj === _typeof.object\n        && obj !== null\n        && !Array.isArray(obj)\n        && !(obj instanceof RegExp)\n        && !(obj instanceof Date);\n}\n/**\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\n * @returns whether the provided parameter is a JavaScript Number or not.\n */\nexport function isNumber(obj) {\n    if ((typeof (obj) === _typeof.number || obj instanceof Number) && !isNaN(obj)) {\n        return true;\n    }\n    return false;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Boolean or not.\n */\nexport function isBoolean(obj) {\n    return obj === true || obj === false;\n}\n/**\n * @returns whether the provided parameter is undefined.\n */\nexport function isUndefined(obj) {\n    return typeof (obj) === _typeof.undefined;\n}\n/**\n * @returns whether the provided parameter is undefined or null.\n */\nexport function isUndefinedOrNull(obj) {\n    return isUndefined(obj) || obj === null;\n}\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n/**\n * @returns whether the provided parameter is an empty JavaScript Object or not.\n */\nexport function isEmptyObject(obj) {\n    if (!isObject(obj)) {\n        return false;\n    }\n    for (var key in obj) {\n        if (hasOwnProperty.call(obj, key)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Function or not.\n */\nexport function isFunction(obj) {\n    return typeof obj === _typeof.function;\n}\nexport function validateConstraints(args, constraints) {\n    var len = Math.min(args.length, constraints.length);\n    for (var i = 0; i < len; i++) {\n        validateConstraint(args[i], constraints[i]);\n    }\n}\nexport function validateConstraint(arg, constraint) {\n    if (isString(constraint)) {\n        if (typeof arg !== constraint) {\n            throw new Error(\"argument does not match constraint: typeof \" + constraint);\n        }\n    }\n    else if (isFunction(constraint)) {\n        try {\n            if (arg instanceof constraint) {\n                return;\n            }\n        }\n        catch (_a) {\n            // ignore\n        }\n        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\n            return;\n        }\n        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\n            return;\n        }\n        throw new Error(\"argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true\");\n    }\n}\n/**\n * Creates a new object of the provided class and will call the constructor with\n * any additional argument supplied.\n */\nexport function create(ctor) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    var _a;\n    if (isNativeClass(ctor)) {\n        return new ((_a = ctor).bind.apply(_a, [void 0].concat(args)))();\n    }\n    else {\n        var obj = Object.create(ctor.prototype);\n        ctor.apply(obj, args);\n        return obj;\n    }\n}\n// https://stackoverflow.com/a/32235645/1499159\nfunction isNativeClass(thing) {\n    return typeof thing === 'function'\n        && thing.hasOwnProperty('prototype')\n        && !thing.hasOwnProperty('arguments');\n}\n/**\n *\n *\n */\nexport function getAllPropertyNames(obj) {\n    var res = [];\n    var proto = Object.getPrototypeOf(obj);\n    while (Object.prototype !== proto) {\n        res = res.concat(Object.getOwnPropertyNames(proto));\n        proto = Object.getPrototypeOf(proto);\n    }\n    return res;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { transformErrorForSerialization } from '../errors.js';\nimport { Disposable } from '../lifecycle.js';\nimport { isWeb } from '../platform.js';\nimport { getAllPropertyNames } from '../types.js';\nvar INITIALIZE = '$initialize';\nvar webWorkerWarningLogged = false;\nexport function logOnceWebWorkerWarning(err) {\n    if (!isWeb) {\n        // running tests\n        return;\n    }\n    if (!webWorkerWarningLogged) {\n        webWorkerWarningLogged = true;\n        console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/Microsoft/monaco-editor#faq');\n    }\n    console.warn(err.message);\n}\nvar SimpleWorkerProtocol = /** @class */ (function () {\n    function SimpleWorkerProtocol(handler) {\n        this._workerId = -1;\n        this._handler = handler;\n        this._lastSentReq = 0;\n        this._pendingReplies = Object.create(null);\n    }\n    SimpleWorkerProtocol.prototype.setWorkerId = function (workerId) {\n        this._workerId = workerId;\n    };\n    SimpleWorkerProtocol.prototype.sendMessage = function (method, args) {\n        var _this = this;\n        var req = String(++this._lastSentReq);\n        return new Promise(function (resolve, reject) {\n            _this._pendingReplies[req] = {\n                resolve: resolve,\n                reject: reject\n            };\n            _this._send({\n                vsWorker: _this._workerId,\n                req: req,\n                method: method,\n                args: args\n            });\n        });\n    };\n    SimpleWorkerProtocol.prototype.handleMessage = function (serializedMessage) {\n        var message;\n        try {\n            message = JSON.parse(serializedMessage);\n        }\n        catch (e) {\n            // nothing\n            return;\n        }\n        if (!message || !message.vsWorker) {\n            return;\n        }\n        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n            return;\n        }\n        this._handleMessage(message);\n    };\n    SimpleWorkerProtocol.prototype._handleMessage = function (msg) {\n        var _this = this;\n        if (msg.seq) {\n            var replyMessage = msg;\n            if (!this._pendingReplies[replyMessage.seq]) {\n                console.warn('Got reply to unknown seq');\n                return;\n            }\n            var reply = this._pendingReplies[replyMessage.seq];\n            delete this._pendingReplies[replyMessage.seq];\n            if (replyMessage.err) {\n                var err = replyMessage.err;\n                if (replyMessage.err.$isError) {\n                    err = new Error();\n                    err.name = replyMessage.err.name;\n                    err.message = replyMessage.err.message;\n                    err.stack = replyMessage.err.stack;\n                }\n                reply.reject(err);\n                return;\n            }\n            reply.resolve(replyMessage.res);\n            return;\n        }\n        var requestMessage = msg;\n        var req = requestMessage.req;\n        var result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n        result.then(function (r) {\n            _this._send({\n                vsWorker: _this._workerId,\n                seq: req,\n                res: r,\n                err: undefined\n            });\n        }, function (e) {\n            if (e.detail instanceof Error) {\n                // Loading errors have a detail property that points to the actual error\n                e.detail = transformErrorForSerialization(e.detail);\n            }\n            _this._send({\n                vsWorker: _this._workerId,\n                seq: req,\n                res: undefined,\n                err: transformErrorForSerialization(e)\n            });\n        });\n    };\n    SimpleWorkerProtocol.prototype._send = function (msg) {\n        var strMsg = JSON.stringify(msg);\n        // console.log('SENDING: ' + strMsg);\n        this._handler.sendMessage(strMsg);\n    };\n    return SimpleWorkerProtocol;\n}());\n/**\n * Main thread side\n */\nvar SimpleWorkerClient = /** @class */ (function (_super) {\n    __extends(SimpleWorkerClient, _super);\n    function SimpleWorkerClient(workerFactory, moduleId) {\n        var _this = _super.call(this) || this;\n        var lazyProxyReject = null;\n        _this._worker = _this._register(workerFactory.create('vs/base/common/worker/simpleWorker', function (msg) {\n            _this._protocol.handleMessage(msg);\n        }, function (err) {\n            // in Firefox, web workers fail lazily :(\n            // we will reject the proxy\n            if (lazyProxyReject) {\n                lazyProxyReject(err);\n            }\n        }));\n        _this._protocol = new SimpleWorkerProtocol({\n            sendMessage: function (msg) {\n                _this._worker.postMessage(msg);\n            },\n            handleMessage: function (method, args) {\n                // Intentionally not supporting worker -> main requests\n                return Promise.resolve(null);\n            }\n        });\n        _this._protocol.setWorkerId(_this._worker.getId());\n        // Gather loader configuration\n        var loaderConfiguration = null;\n        if (typeof self.require !== 'undefined' && typeof self.require.getConfig === 'function') {\n            // Get the configuration from the Monaco AMD Loader\n            loaderConfiguration = self.require.getConfig();\n        }\n        else if (typeof self.requirejs !== 'undefined') {\n            // Get the configuration from requirejs\n            loaderConfiguration = self.requirejs.s.contexts._.config;\n        }\n        // Send initialize message\n        _this._onModuleLoaded = _this._protocol.sendMessage(INITIALIZE, [\n            _this._worker.getId(),\n            moduleId,\n            loaderConfiguration\n        ]);\n        _this._lazyProxy = new Promise(function (resolve, reject) {\n            lazyProxyReject = reject;\n            _this._onModuleLoaded.then(function (availableMethods) {\n                var proxy = {};\n                for (var _i = 0, availableMethods_1 = availableMethods; _i < availableMethods_1.length; _i++) {\n                    var methodName = availableMethods_1[_i];\n                    proxy[methodName] = createProxyMethod(methodName, proxyMethodRequest);\n                }\n                resolve(proxy);\n            }, function (e) {\n                reject(e);\n                _this._onError('Worker failed to load ' + moduleId, e);\n            });\n        });\n        // Create proxy to loaded code\n        var proxyMethodRequest = function (method, args) {\n            return _this._request(method, args);\n        };\n        var createProxyMethod = function (method, proxyMethodRequest) {\n            return function () {\n                var args = Array.prototype.slice.call(arguments, 0);\n                return proxyMethodRequest(method, args);\n            };\n        };\n        return _this;\n    }\n    SimpleWorkerClient.prototype.getProxyObject = function () {\n        return this._lazyProxy;\n    };\n    SimpleWorkerClient.prototype._request = function (method, args) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this._onModuleLoaded.then(function () {\n                _this._protocol.sendMessage(method, args).then(resolve, reject);\n            }, reject);\n        });\n    };\n    SimpleWorkerClient.prototype._onError = function (message, error) {\n        console.error(message);\n        console.info(error);\n    };\n    return SimpleWorkerClient;\n}(Disposable));\nexport { SimpleWorkerClient };\n/**\n * Worker side\n */\nvar SimpleWorkerServer = /** @class */ (function () {\n    function SimpleWorkerServer(postSerializedMessage, requestHandler) {\n        var _this = this;\n        this._requestHandler = requestHandler;\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: function (msg) {\n                postSerializedMessage(msg);\n            },\n            handleMessage: function (method, args) { return _this._handleMessage(method, args); }\n        });\n    }\n    SimpleWorkerServer.prototype.onmessage = function (msg) {\n        this._protocol.handleMessage(msg);\n    };\n    SimpleWorkerServer.prototype._handleMessage = function (method, args) {\n        if (method === INITIALIZE) {\n            return this.initialize(args[0], args[1], args[2]);\n        }\n        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    };\n    SimpleWorkerServer.prototype.initialize = function (workerId, moduleId, loaderConfig) {\n        var _this = this;\n        this._protocol.setWorkerId(workerId);\n        if (this._requestHandler) {\n            // static request handler\n            var methods = [];\n            for (var _i = 0, _a = getAllPropertyNames(this._requestHandler); _i < _a.length; _i++) {\n                var prop = _a[_i];\n                if (typeof this._requestHandler[prop] === 'function') {\n                    methods.push(prop);\n                }\n            }\n            return Promise.resolve(methods);\n        }\n        if (loaderConfig) {\n            // Remove 'baseUrl', handling it is beyond scope for now\n            if (typeof loaderConfig.baseUrl !== 'undefined') {\n                delete loaderConfig['baseUrl'];\n            }\n            if (typeof loaderConfig.paths !== 'undefined') {\n                if (typeof loaderConfig.paths.vs !== 'undefined') {\n                    delete loaderConfig.paths['vs'];\n                }\n            }\n            // Since this is in a web worker, enable catching errors\n            loaderConfig.catchError = true;\n            self.require.config(loaderConfig);\n        }\n        return new Promise(function (resolve, reject) {\n            // Use the global require to be sure to get the global config\n            self.require([moduleId], function () {\n                var result = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    result[_i] = arguments[_i];\n                }\n                var handlerModule = result[0];\n                _this._requestHandler = handlerModule.create();\n                if (!_this._requestHandler) {\n                    reject(new Error(\"No RequestHandler!\"));\n                    return;\n                }\n                var methods = [];\n                for (var _a = 0, _b = getAllPropertyNames(_this._requestHandler); _a < _b.length; _a++) {\n                    var prop = _b[_a];\n                    if (typeof _this._requestHandler[prop] === 'function') {\n                        methods.push(prop);\n                    }\n                }\n                resolve(methods);\n            }, reject);\n        });\n    };\n    return SimpleWorkerServer;\n}());\nexport { SimpleWorkerServer };\n/**\n * Called on the worker side\n */\nexport function create(postMessage) {\n    return new SimpleWorkerServer(postMessage, null);\n}\n","/**\n * Returns the last element of an array.\n * @param array The array.\n * @param n Which element from the end (default is zero).\n */\nexport function tail(array, n) {\n    if (n === void 0) { n = 0; }\n    return array[array.length - (1 + n)];\n}\nexport function tail2(arr) {\n    if (arr.length === 0) {\n        throw new Error('Invalid tail call');\n    }\n    return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];\n}\nexport function equals(one, other, itemEquals) {\n    if (itemEquals === void 0) { itemEquals = function (a, b) { return a === b; }; }\n    if (one === other) {\n        return true;\n    }\n    if (!one || !other) {\n        return false;\n    }\n    if (one.length !== other.length) {\n        return false;\n    }\n    for (var i = 0, len = one.length; i < len; i++) {\n        if (!itemEquals(one[i], other[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function binarySearch(array, key, comparator) {\n    var low = 0, high = array.length - 1;\n    while (low <= high) {\n        var mid = ((low + high) / 2) | 0;\n        var comp = comparator(array[mid], key);\n        if (comp < 0) {\n            low = mid + 1;\n        }\n        else if (comp > 0) {\n            high = mid - 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return -(low + 1);\n}\n/**\n * Takes a sorted array and a function p. The array is sorted in such a way that all elements where p(x) is false\n * are located before all elements where p(x) is true.\n * @returns the least x for which p(x) is true or array.length if no element fullfills the given function.\n */\nexport function findFirstInSorted(array, p) {\n    var low = 0, high = array.length;\n    if (high === 0) {\n        return 0; // no children\n    }\n    while (low < high) {\n        var mid = Math.floor((low + high) / 2);\n        if (p(array[mid])) {\n            high = mid;\n        }\n        else {\n            low = mid + 1;\n        }\n    }\n    return low;\n}\n/**\n * Like `Array#sort` but always stable. Usually runs a little slower `than Array#sort`\n * so only use this when actually needing stable sort.\n */\nexport function mergeSort(data, compare) {\n    _sort(data, compare, 0, data.length - 1, []);\n    return data;\n}\nfunction _merge(a, compare, lo, mid, hi, aux) {\n    var leftIdx = lo, rightIdx = mid + 1;\n    for (var i = lo; i <= hi; i++) {\n        aux[i] = a[i];\n    }\n    for (var i = lo; i <= hi; i++) {\n        if (leftIdx > mid) {\n            // left side consumed\n            a[i] = aux[rightIdx++];\n        }\n        else if (rightIdx > hi) {\n            // right side consumed\n            a[i] = aux[leftIdx++];\n        }\n        else if (compare(aux[rightIdx], aux[leftIdx]) < 0) {\n            // right element is less -> comes first\n            a[i] = aux[rightIdx++];\n        }\n        else {\n            // left element comes first (less or equal)\n            a[i] = aux[leftIdx++];\n        }\n    }\n}\nfunction _sort(a, compare, lo, hi, aux) {\n    if (hi <= lo) {\n        return;\n    }\n    var mid = lo + ((hi - lo) / 2) | 0;\n    _sort(a, compare, lo, mid, aux);\n    _sort(a, compare, mid + 1, hi, aux);\n    if (compare(a[mid], a[mid + 1]) <= 0) {\n        // left and right are sorted and if the last-left element is less\n        // or equals than the first-right element there is nothing else\n        // to do\n        return;\n    }\n    _merge(a, compare, lo, mid, hi, aux);\n}\nexport function groupBy(data, compare) {\n    var result = [];\n    var currentGroup = undefined;\n    for (var _i = 0, _a = mergeSort(data.slice(0), compare); _i < _a.length; _i++) {\n        var element = _a[_i];\n        if (!currentGroup || compare(currentGroup[0], element) !== 0) {\n            currentGroup = [element];\n            result.push(currentGroup);\n        }\n        else {\n            currentGroup.push(element);\n        }\n    }\n    return result;\n}\n/**\n * @returns a new array with all falsy values removed. The original array IS NOT modified.\n */\nexport function coalesce(array) {\n    if (!array) {\n        return array;\n    }\n    return array.filter(function (e) { return !!e; });\n}\n/**\n * @returns false if the provided object is an array and not empty.\n */\nexport function isFalsyOrEmpty(obj) {\n    return !Array.isArray(obj) || obj.length === 0;\n}\n/**\n * @returns True if the provided object is an array and has at least one element.\n */\nexport function isNonEmptyArray(obj) {\n    return Array.isArray(obj) && obj.length > 0;\n}\n/**\n * Removes duplicates from the given array. The optional keyFn allows to specify\n * how elements are checked for equalness by returning a unique string for each.\n */\nexport function distinct(array, keyFn) {\n    if (!keyFn) {\n        return array.filter(function (element, position) {\n            return array.indexOf(element) === position;\n        });\n    }\n    var seen = Object.create(null);\n    return array.filter(function (elem) {\n        var key = keyFn(elem);\n        if (seen[key]) {\n            return false;\n        }\n        seen[key] = true;\n        return true;\n    });\n}\nexport function firstIndex(array, fn) {\n    for (var i = 0; i < array.length; i++) {\n        var element = array[i];\n        if (fn(element)) {\n            return i;\n        }\n    }\n    return -1;\n}\nexport function first(array, fn, notFoundValue) {\n    if (notFoundValue === void 0) { notFoundValue = null; }\n    var index = firstIndex(array, fn);\n    return index < 0 ? notFoundValue : array[index];\n}\nexport function flatten(arr) {\n    var _a;\n    return (_a = []).concat.apply(_a, arr);\n}\nexport function range(arg, to) {\n    var from = typeof to === 'number' ? arg : 0;\n    if (typeof to === 'number') {\n        from = arg;\n    }\n    else {\n        from = 0;\n        to = arg;\n    }\n    var result = [];\n    if (from <= to) {\n        for (var i = from; i < to; i++) {\n            result.push(i);\n        }\n    }\n    else {\n        for (var i = from; i > to; i--) {\n            result.push(i);\n        }\n    }\n    return result;\n}\n/**\n * Insert `insertArr` inside `target` at `insertIndex`.\n * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array\n */\nexport function arrayInsert(target, insertIndex, insertArr) {\n    var before = target.slice(0, insertIndex);\n    var after = target.slice(insertIndex);\n    return before.concat(insertArr, after);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nvar DiffChange = /** @class */ (function () {\n    /**\n     * Constructs a new DiffChange with the given sequence information\n     * and content.\n     */\n    function DiffChange(originalStart, originalLength, modifiedStart, modifiedLength) {\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n        this.originalStart = originalStart;\n        this.originalLength = originalLength;\n        this.modifiedStart = modifiedStart;\n        this.modifiedLength = modifiedLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the original sequence.\n     */\n    DiffChange.prototype.getOriginalEnd = function () {\n        return this.originalStart + this.originalLength;\n    };\n    /**\n     * The end point (exclusive) of the change in the modified sequence.\n     */\n    DiffChange.prototype.getModifiedEnd = function () {\n        return this.modifiedStart + this.modifiedLength;\n    };\n    return DiffChange;\n}());\nexport { DiffChange };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { DiffChange } from './diffChange.js';\nfunction createStringSequence(a) {\n    return {\n        getLength: function () { return a.length; },\n        getElementAtIndex: function (pos) { return a.charCodeAt(pos); }\n    };\n}\nexport function stringDiff(original, modified, pretty) {\n    return new LcsDiff(createStringSequence(original), createStringSequence(modified)).ComputeDiff(pretty);\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nvar Debug = /** @class */ (function () {\n    function Debug() {\n    }\n    Debug.Assert = function (condition, message) {\n        if (!condition) {\n            throw new Error(message);\n        }\n    };\n    return Debug;\n}());\nexport { Debug };\nvar MyArray = /** @class */ (function () {\n    function MyArray() {\n    }\n    /**\n     * Copies a range of elements from an Array starting at the specified source index and pastes\n     * them to another Array starting at the specified destination index. The length and the indexes\n     * are specified as 64-bit integers.\n     * sourceArray:\n     *\t\tThe Array that contains the data to copy.\n     * sourceIndex:\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n     * destinationArray:\n     *\t\tThe Array that receives the data.\n     * destinationIndex:\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n     * length:\n     *\t\tA 64-bit integer that represents the number of elements to copy.\n     */\n    MyArray.Copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (var i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    };\n    return MyArray;\n}());\nexport { MyArray };\n//*****************************************************************************\n// LcsDiff.cs\n//\n// An implementation of the difference algorithm described in\n// \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n//\n// Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve\n//*****************************************************************************\n// Our total memory usage for storing history is (worst-case):\n// 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)\n// 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB\nvar MaxDifferencesHistory = 1447;\n//let MaxDifferencesHistory = 100;\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarktNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nvar DiffChangeHelper = /** @class */ (function () {\n    /**\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\n     */\n    function DiffChangeHelper() {\n        this.m_changes = [];\n        this.m_originalStart = Number.MAX_VALUE;\n        this.m_modifiedStart = Number.MAX_VALUE;\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n    }\n    /**\n     * Marks the beginning of the next change in the set of differences.\n     */\n    DiffChangeHelper.prototype.MarkNextChange = function () {\n        // Only add to the list if there is something to add\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Add the new change to our list\n            this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n        }\n        // Reset for the next change\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n        this.m_originalStart = Number.MAX_VALUE;\n        this.m_modifiedStart = Number.MAX_VALUE;\n    };\n    /**\n     * Adds the original element at the given position to the elements\n     * affected by the current change. The modified index gives context\n     * to the change position with respect to the original sequence.\n     * @param originalIndex The index of the original element to add.\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n     */\n    DiffChangeHelper.prototype.AddOriginalElement = function (originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_originalCount++;\n    };\n    /**\n     * Adds the modified element at the given position to the elements\n     * affected by the current change. The original index gives context\n     * to the change position with respect to the modified sequence.\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n     * @param modifiedIndex The index of the modified element to add.\n     */\n    DiffChangeHelper.prototype.AddModifiedElement = function (originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_modifiedCount++;\n    };\n    /**\n     * Retrieves all of the changes marked by the class.\n     */\n    DiffChangeHelper.prototype.getChanges = function () {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        return this.m_changes;\n    };\n    /**\n     * Retrieves all of the changes marked by the class in the reverse order\n     */\n    DiffChangeHelper.prototype.getReverseChanges = function () {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        this.m_changes.reverse();\n        return this.m_changes;\n    };\n    return DiffChangeHelper;\n}());\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nvar LcsDiff = /** @class */ (function () {\n    /**\n     * Constructs the DiffFinder\n     */\n    function LcsDiff(originalSequence, newSequence, continueProcessingPredicate) {\n        if (continueProcessingPredicate === void 0) { continueProcessingPredicate = null; }\n        this.OriginalSequence = originalSequence;\n        this.ModifiedSequence = newSequence;\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n    }\n    LcsDiff.prototype.ElementsAreEqual = function (originalIndex, newIndex) {\n        return (this.OriginalSequence.getElementAtIndex(originalIndex) === this.ModifiedSequence.getElementAtIndex(newIndex));\n    };\n    LcsDiff.prototype.OriginalElementsAreEqual = function (index1, index2) {\n        return (this.OriginalSequence.getElementAtIndex(index1) === this.OriginalSequence.getElementAtIndex(index2));\n    };\n    LcsDiff.prototype.ModifiedElementsAreEqual = function (index1, index2) {\n        return (this.ModifiedSequence.getElementAtIndex(index1) === this.ModifiedSequence.getElementAtIndex(index2));\n    };\n    LcsDiff.prototype.ComputeDiff = function (pretty) {\n        return this._ComputeDiff(0, this.OriginalSequence.getLength() - 1, 0, this.ModifiedSequence.getLength() - 1, pretty);\n    };\n    /**\n     * Computes the differences between the original and modified input\n     * sequences on the bounded range.\n     * @returns An array of the differences between the two input sequences.\n     */\n    LcsDiff.prototype._ComputeDiff = function (originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n        var quitEarlyArr = [false];\n        var changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n        if (pretty) {\n            // We have to clean up the computed diff to be more intuitive\n            // but it turns out this cannot be done correctly until the entire set\n            // of diffs have been computed\n            return this.PrettifyChanges(changes);\n        }\n        return changes;\n    };\n    /**\n     * Private helper method which computes the differences on the bounded range\n     * recursively.\n     * @returns An array of the differences between the two input sequences.\n     */\n    LcsDiff.prototype.ComputeDiffRecursive = function (originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n        quitEarlyArr[0] = false;\n        // Find the start of the differences\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n            originalStart++;\n            modifiedStart++;\n        }\n        // Find the end of the differences\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n            originalEnd--;\n            modifiedEnd--;\n        }\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n            var changes = void 0;\n            if (modifiedStart <= modifiedEnd) {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                // All insertions\n                changes = [\n                    new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n                ];\n            }\n            else if (originalStart <= originalEnd) {\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // All deletions\n                changes = [\n                    new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n                ];\n            }\n            else {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // Identical sequences - No differences\n                changes = [];\n            }\n            return changes;\n        }\n        // This problem can be solved using the Divide-And-Conquer technique.\n        var midOriginalArr = [0], midModifiedArr = [0];\n        var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n        var midOriginal = midOriginalArr[0];\n        var midModified = midModifiedArr[0];\n        if (result !== null) {\n            // Result is not-null when there was enough memory to compute the changes while\n            // searching for the recursion point\n            return result;\n        }\n        else if (!quitEarlyArr[0]) {\n            // We can break the problem down recursively by finding the changes in the\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n            var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n            var rightChanges = [];\n            if (!quitEarlyArr[0]) {\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n            }\n            else {\n                // We did't have time to finish the first half, so we don't have time to compute this half.\n                // Consider the entire rest of the sequence different.\n                rightChanges = [\n                    new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n                ];\n            }\n            return this.ConcatenateChanges(leftChanges, rightChanges);\n        }\n        // If we hit here, we quit early, and so can't return anything meaningful\n        return [\n            new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n        ];\n    };\n    LcsDiff.prototype.WALKTRACE = function (diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n        var forwardChanges = null, reverseChanges = null;\n        // First, walk backward through the forward diagonals history\n        var changeHelper = new DiffChangeHelper();\n        var diagonalMin = diagonalForwardStart;\n        var diagonalMax = diagonalForwardEnd;\n        var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n        var lastOriginalIndex = Number.MIN_VALUE;\n        var historyIndex = this.m_forwardHistory.length - 1;\n        var diagonal;\n        do {\n            // Get the diagonal index from the relative diagonal number\n            diagonal = diagonalRelative + diagonalForwardBase;\n            // Figure out where we came from\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                // Vertical line (the element is an insert)\n                originalIndex = forwardPoints[diagonal + 1];\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex;\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            else {\n                // Horizontal line (the element is a deletion)\n                originalIndex = forwardPoints[diagonal - 1] + 1;\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex - 1;\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            if (historyIndex >= 0) {\n                forwardPoints = this.m_forwardHistory[historyIndex];\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n                diagonalMin = 1;\n                diagonalMax = forwardPoints.length - 1;\n            }\n        } while (--historyIndex >= -1);\n        // Ironically, we get the forward changes as the reverse of the\n        // order we added them since we technically added them backwards\n        forwardChanges = changeHelper.getReverseChanges();\n        if (quitEarlyArr[0]) {\n            // TODO: Calculate a partial from the reverse diagonals.\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\n            var originalStartPoint = midOriginalArr[0] + 1;\n            var modifiedStartPoint = midModifiedArr[0] + 1;\n            if (forwardChanges !== null && forwardChanges.length > 0) {\n                var lastForwardChange = forwardChanges[forwardChanges.length - 1];\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n            }\n            reverseChanges = [\n                new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n            ];\n        }\n        else {\n            // Now walk backward through the reverse diagonals history\n            changeHelper = new DiffChangeHelper();\n            diagonalMin = diagonalReverseStart;\n            diagonalMax = diagonalReverseEnd;\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n            lastOriginalIndex = Number.MAX_VALUE;\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n            do {\n                // Get the diagonal index from the relative diagonal number\n                diagonal = diagonalRelative + diagonalReverseBase;\n                // Figure out where we came from\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    // Horizontal line (the element is a deletion))\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex + 1;\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                else {\n                    // Vertical line (the element is an insertion)\n                    originalIndex = reversePoints[diagonal - 1];\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex;\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                if (historyIndex >= 0) {\n                    reversePoints = this.m_reverseHistory[historyIndex];\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n                    diagonalMin = 1;\n                    diagonalMax = reversePoints.length - 1;\n                }\n            } while (--historyIndex >= -1);\n            // There are cases where the reverse history will find diffs that\n            // are correct, but not intuitive, so we need shift them.\n            reverseChanges = changeHelper.getChanges();\n        }\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\n    };\n    /**\n     * Given the range to compute the diff on, this method finds the point:\n     * (midOriginal, midModified)\n     * that exists in the middle of the LCS of the two sequences and\n     * is the point at which the LCS problem may be broken down recursively.\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\n     * point is calculated and the full trace is available in memory, then this method\n     * will return the change list.\n     * @param originalStart The start bound of the original sequence range\n     * @param originalEnd The end bound of the original sequence range\n     * @param modifiedStart The start bound of the modified sequence range\n     * @param modifiedEnd The end bound of the modified sequence range\n     * @param midOriginal The middle point of the original sequence range\n     * @param midModified The middle point of the modified sequence range\n     * @returns The diff changes, if available, otherwise null\n     */\n    LcsDiff.prototype.ComputeRecursionPoint = function (originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n        var originalIndex = 0, modifiedIndex = 0;\n        var diagonalForwardStart = 0, diagonalForwardEnd = 0;\n        var diagonalReverseStart = 0, diagonalReverseEnd = 0;\n        var numDifferences;\n        // To traverse the edit graph and produce the proper LCS, our actual\n        // start position is just outside the given boundary\n        originalStart--;\n        modifiedStart--;\n        // We set these up to make the compiler happy, but they will\n        // be replaced before we return with the actual recursion point\n        midOriginalArr[0] = 0;\n        midModifiedArr[0] = 0;\n        // Clear out the history\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n        // The integer value in the cell represents the originalIndex of the furthest\n        // reaching point found so far that ends in that diagonal.\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n        var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n        var numDiagonals = maxDifferences + 1;\n        var forwardPoints = new Array(numDiagonals);\n        var reversePoints = new Array(numDiagonals);\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n        var diagonalForwardBase = (modifiedEnd - modifiedStart);\n        var diagonalReverseBase = (originalEnd - originalStart);\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalForwardBase)\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalReverseBase)\n        var diagonalForwardOffset = (originalStart - modifiedStart);\n        var diagonalReverseOffset = (originalEnd - modifiedEnd);\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n        var delta = diagonalReverseBase - diagonalForwardBase;\n        var deltaIsEven = (delta % 2 === 0);\n        // Here we set up the start and end points as the furthest points found so far\n        // in both the forward and reverse directions, respectively\n        forwardPoints[diagonalForwardBase] = originalStart;\n        reversePoints[diagonalReverseBase] = originalEnd;\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n        quitEarlyArr[0] = false;\n        // A couple of points:\n        // --With this method, we iterate on the number of differences between the two sequences.\n        //   The more differences there actually are, the longer this will take.\n        // --Also, as the number of differences increases, we have to search on diagonals further\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n        //   is even and odd diagonals only when numDifferences is odd.\n        var diagonal, tempOriginalIndex;\n        for (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n            var furthestOriginalIndex = 0;\n            var furthestModifiedIndex = 0;\n            // Run the algorithm in the forward direction\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            for (diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalStart, modifiedStart)\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                    originalIndex = forwardPoints[diagonal + 1];\n                }\n                else {\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n                // Save the current originalIndex so we can test for false overlap in step 3\n                tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // so long as the elements are equal.\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n                    originalIndex++;\n                    modifiedIndex++;\n                }\n                forwardPoints[diagonal] = originalIndex;\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n                    furthestOriginalIndex = originalIndex;\n                    furthestModifiedIndex = modifiedIndex;\n                }\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n                // then check for overlap.\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n                    if (originalIndex >= reversePoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex <= reversePoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Check to see if we should be quitting early, before moving on to the next iteration.\n            var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {\n                // We can't finish, so skip ahead to generating a result from what we have.\n                quitEarlyArr[0] = true;\n                // Use the furthest distance we got in the forward direction.\n                midOriginalArr[0] = furthestOriginalIndex;\n                midModifiedArr[0] = furthestModifiedIndex;\n                if (matchLengthOfLongest > 0 && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                    // Enough of the history is in memory to walk it backwards\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                }\n                else {\n                    // We didn't actually remember enough of the history.\n                    //Since we are quiting the diff early, we need to shift back the originalStart and modified start\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\n                    originalStart++;\n                    modifiedStart++;\n                    return [\n                        new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n                    ];\n                }\n            }\n            // Run the algorithm in the reverse direction\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            for (diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalEnd, modifiedEnd)\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                }\n                else {\n                    originalIndex = reversePoints[diagonal - 1];\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n                // Save the current originalIndex so we can test for false overlap\n                tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // as long as the elements are equal.\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n                    originalIndex--;\n                    modifiedIndex--;\n                }\n                reversePoints[diagonal] = originalIndex;\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n                // and diagonal is in the range of forward diagonals computed for numDifferences\n                // then check for overlap.\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n                    if (originalIndex <= forwardPoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Save current vectors to history before the next iteration\n            if (numDifferences <= MaxDifferencesHistory) {\n                // We are allocating space for one extra int, which we fill with\n                // the index of the diagonal base index\n                var temp = new Array(diagonalForwardEnd - diagonalForwardStart + 2);\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n                MyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n                this.m_forwardHistory.push(temp);\n                temp = new Array(diagonalReverseEnd - diagonalReverseStart + 2);\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n                MyArray.Copy(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n                this.m_reverseHistory.push(temp);\n            }\n        }\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\n        // NOTE: This part is a bit messy\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n    };\n    /**\n     * Shifts the given changes to provide a more intuitive diff.\n     * While the first element in a diff matches the first element after the diff,\n     * we shift the diff down.\n     *\n     * @param changes The list of changes to shift\n     * @returns The shifted changes\n     */\n    LcsDiff.prototype.PrettifyChanges = function (changes) {\n        // Shift all the changes down first\n        for (var i = 0; i < changes.length; i++) {\n            var change = changes[i];\n            var originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this.OriginalSequence.getLength();\n            var modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this.ModifiedSequence.getLength();\n            var checkOriginal = change.originalLength > 0;\n            var checkModified = change.modifiedLength > 0;\n            while (change.originalStart + change.originalLength < originalStop &&\n                change.modifiedStart + change.modifiedLength < modifiedStop &&\n                (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) &&\n                (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n                change.originalStart++;\n                change.modifiedStart++;\n            }\n            var mergedChangeArr = [null];\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n                changes[i] = mergedChangeArr[0];\n                changes.splice(i + 1, 1);\n                i--;\n                continue;\n            }\n        }\n        // Shift changes back up until we hit empty or whitespace-only lines\n        for (var i = changes.length - 1; i >= 0; i--) {\n            var change = changes[i];\n            var originalStop = 0;\n            var modifiedStop = 0;\n            if (i > 0) {\n                var prevChange = changes[i - 1];\n                if (prevChange.originalLength > 0) {\n                    originalStop = prevChange.originalStart + prevChange.originalLength;\n                }\n                if (prevChange.modifiedLength > 0) {\n                    modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n                }\n            }\n            var checkOriginal = change.originalLength > 0;\n            var checkModified = change.modifiedLength > 0;\n            var bestDelta = 0;\n            var bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n            for (var delta = 1;; delta++) {\n                var originalStart = change.originalStart - delta;\n                var modifiedStart = change.modifiedStart - delta;\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\n                    break;\n                }\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n                    break;\n                }\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n                    break;\n                }\n                var score = this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength);\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestDelta = delta;\n                }\n            }\n            change.originalStart -= bestDelta;\n            change.modifiedStart -= bestDelta;\n        }\n        return changes;\n    };\n    LcsDiff.prototype._OriginalIsBoundary = function (index) {\n        if (index <= 0 || index >= this.OriginalSequence.getLength() - 1) {\n            return true;\n        }\n        var element = this.OriginalSequence.getElementAtIndex(index);\n        return (typeof element === 'string' && /^\\s*$/.test(element));\n    };\n    LcsDiff.prototype._OriginalRegionIsBoundary = function (originalStart, originalLength) {\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n            return true;\n        }\n        if (originalLength > 0) {\n            var originalEnd = originalStart + originalLength;\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    LcsDiff.prototype._ModifiedIsBoundary = function (index) {\n        if (index <= 0 || index >= this.ModifiedSequence.getLength() - 1) {\n            return true;\n        }\n        var element = this.ModifiedSequence.getElementAtIndex(index);\n        return (typeof element === 'string' && /^\\s*$/.test(element));\n    };\n    LcsDiff.prototype._ModifiedRegionIsBoundary = function (modifiedStart, modifiedLength) {\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n            return true;\n        }\n        if (modifiedLength > 0) {\n            var modifiedEnd = modifiedStart + modifiedLength;\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    LcsDiff.prototype._boundaryScore = function (originalStart, originalLength, modifiedStart, modifiedLength) {\n        var originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n        var modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n        return (originalScore + modifiedScore);\n    };\n    /**\n     * Concatenates the two input DiffChange lists and returns the resulting\n     * list.\n     * @param The left changes\n     * @param The right changes\n     * @returns The concatenated list\n     */\n    LcsDiff.prototype.ConcatenateChanges = function (left, right) {\n        var mergedChangeArr = [];\n        if (left.length === 0 || right.length === 0) {\n            return (right.length > 0) ? right : left;\n        }\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n            // Since we break the problem down recursively, it is possible that we\n            // might recurse in the middle of a change thereby splitting it into\n            // two changes. Here in the combining stage, we detect and fuse those\n            // changes back together\n            var result = new Array(left.length + right.length - 1);\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\n            result[left.length - 1] = mergedChangeArr[0];\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\n            return result;\n        }\n        else {\n            var result = new Array(left.length + right.length);\n            MyArray.Copy(left, 0, result, 0, left.length);\n            MyArray.Copy(right, 0, result, left.length, right.length);\n            return result;\n        }\n    };\n    /**\n     * Returns true if the two changes overlap and can be merged into a single\n     * change\n     * @param left The left change\n     * @param right The right change\n     * @param mergedChange The merged change if the two overlap, null otherwise\n     * @returns True if the two changes overlap\n     */\n    LcsDiff.prototype.ChangesOverlap = function (left, right, mergedChangeArr) {\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n            var originalStart = left.originalStart;\n            var originalLength = left.originalLength;\n            var modifiedStart = left.modifiedStart;\n            var modifiedLength = left.modifiedLength;\n            if (left.originalStart + left.originalLength >= right.originalStart) {\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\n            }\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n            }\n            mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n            return true;\n        }\n        else {\n            mergedChangeArr[0] = null;\n            return false;\n        }\n    };\n    /**\n     * Helper method used to clip a diagonal index to the range of valid\n     * diagonals. This also decides whether or not the diagonal index,\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\n     * one inside the boundary depending on the Even/Odd status of the boundary\n     * and numDifferences.\n     * @param diagonal The index of the diagonal to clip.\n     * @param numDifferences The current number of differences being iterated upon.\n     * @param diagonalBaseIndex The base reference diagonal.\n     * @param numDiagonals The total number of diagonals.\n     * @returns The clipped diagonal index.\n     */\n    LcsDiff.prototype.ClipDiagonalBound = function (diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n        if (diagonal >= 0 && diagonal < numDiagonals) {\n            // Nothing to clip, its in range\n            return diagonal;\n        }\n        // diagonalsBelow: The number of diagonals below the reference diagonal\n        // diagonalsAbove: The number of diagonals above the reference diagonal\n        var diagonalsBelow = diagonalBaseIndex;\n        var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n        var diffEven = (numDifferences % 2 === 0);\n        if (diagonal < 0) {\n            var lowerBoundEven = (diagonalsBelow % 2 === 0);\n            return (diffEven === lowerBoundEven) ? 0 : 1;\n        }\n        else {\n            var upperBoundEven = (diagonalsAbove % 2 === 0);\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n        }\n    };\n    return LcsDiff;\n}());\nexport { LcsDiff };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nexport var FIN = { done: true, value: undefined };\nexport var Iterator;\n(function (Iterator) {\n    var _empty = {\n        next: function () {\n            return FIN;\n        }\n    };\n    function empty() {\n        return _empty;\n    }\n    Iterator.empty = empty;\n    function fromArray(array, index, length) {\n        if (index === void 0) { index = 0; }\n        if (length === void 0) { length = array.length; }\n        return {\n            next: function () {\n                if (index >= length) {\n                    return FIN;\n                }\n                return { done: false, value: array[index++] };\n            }\n        };\n    }\n    Iterator.fromArray = fromArray;\n    function from(elements) {\n        if (!elements) {\n            return Iterator.empty();\n        }\n        else if (Array.isArray(elements)) {\n            return Iterator.fromArray(elements);\n        }\n        else {\n            return elements;\n        }\n    }\n    Iterator.from = from;\n    function map(iterator, fn) {\n        return {\n            next: function () {\n                var element = iterator.next();\n                if (element.done) {\n                    return FIN;\n                }\n                else {\n                    return { done: false, value: fn(element.value) };\n                }\n            }\n        };\n    }\n    Iterator.map = map;\n    function filter(iterator, fn) {\n        return {\n            next: function () {\n                while (true) {\n                    var element = iterator.next();\n                    if (element.done) {\n                        return FIN;\n                    }\n                    if (fn(element.value)) {\n                        return { done: false, value: element.value };\n                    }\n                }\n            }\n        };\n    }\n    Iterator.filter = filter;\n    function forEach(iterator, fn) {\n        for (var next = iterator.next(); !next.done; next = iterator.next()) {\n            fn(next.value);\n        }\n    }\n    Iterator.forEach = forEach;\n    function collect(iterator) {\n        var result = [];\n        forEach(iterator, function (value) { return result.push(value); });\n        return result;\n    }\n    Iterator.collect = collect;\n})(Iterator || (Iterator = {}));\nexport function getSequenceIterator(arg) {\n    if (Array.isArray(arg)) {\n        return Iterator.fromArray(arg);\n    }\n    else {\n        return arg;\n    }\n}\nvar ArrayIterator = /** @class */ (function () {\n    function ArrayIterator(items, start, end, index) {\n        if (start === void 0) { start = 0; }\n        if (end === void 0) { end = items.length; }\n        if (index === void 0) { index = start - 1; }\n        this.items = items;\n        this.start = start;\n        this.end = end;\n        this.index = index;\n    }\n    ArrayIterator.prototype.next = function () {\n        this.index = Math.min(this.index + 1, this.end);\n        return this.current();\n    };\n    ArrayIterator.prototype.current = function () {\n        if (this.index === this.start - 1 || this.index === this.end) {\n            return null;\n        }\n        return this.items[this.index];\n    };\n    return ArrayIterator;\n}());\nexport { ArrayIterator };\nvar ArrayNavigator = /** @class */ (function (_super) {\n    __extends(ArrayNavigator, _super);\n    function ArrayNavigator(items, start, end, index) {\n        if (start === void 0) { start = 0; }\n        if (end === void 0) { end = items.length; }\n        if (index === void 0) { index = start - 1; }\n        return _super.call(this, items, start, end, index) || this;\n    }\n    ArrayNavigator.prototype.current = function () {\n        return _super.prototype.current.call(this);\n    };\n    ArrayNavigator.prototype.previous = function () {\n        this.index = Math.max(this.index - 1, this.start - 1);\n        return this.current();\n    };\n    ArrayNavigator.prototype.first = function () {\n        this.index = this.start;\n        return this.current();\n    };\n    ArrayNavigator.prototype.last = function () {\n        this.index = this.end - 1;\n        return this.current();\n    };\n    ArrayNavigator.prototype.parent = function () {\n        return null;\n    };\n    return ArrayNavigator;\n}(ArrayIterator));\nexport { ArrayNavigator };\nvar MappedIterator = /** @class */ (function () {\n    function MappedIterator(iterator, fn) {\n        this.iterator = iterator;\n        this.fn = fn;\n        // noop\n    }\n    MappedIterator.prototype.next = function () { return this.fn(this.iterator.next()); };\n    return MappedIterator;\n}());\nexport { MappedIterator };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar _a;\nimport { isWindows } from './platform.js';\nvar _schemePattern = /^\\w[\\w\\d+.-]*$/;\nvar _singleSlashStart = /^\\//;\nvar _doubleSlashStart = /^\\/\\//;\nvar _throwOnMissingSchema = true;\nfunction _validateUri(ret, _strict) {\n    // scheme, must be set\n    if (!ret.scheme) {\n        if (_strict || _throwOnMissingSchema) {\n            throw new Error(\"[UriError]: Scheme is missing: {scheme: \\\"\\\", authority: \\\"\" + ret.authority + \"\\\", path: \\\"\" + ret.path + \"\\\", query: \\\"\" + ret.query + \"\\\", fragment: \\\"\" + ret.fragment + \"\\\"}\");\n        }\n        else {\n            console.warn(\"[UriError]: Scheme is missing: {scheme: \\\"\\\", authority: \\\"\" + ret.authority + \"\\\", path: \\\"\" + ret.path + \"\\\", query: \\\"\" + ret.query + \"\\\", fragment: \\\"\" + ret.fragment + \"\\\"}\");\n        }\n    }\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n        throw new Error('[UriError]: Scheme contains illegal characters.');\n    }\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\n    // If a URI contains an authority component, then the path component\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\n    // does not contain an authority component, then the path cannot begin\n    // with two slash characters (\"//\").\n    if (ret.path) {\n        if (ret.authority) {\n            if (!_singleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character');\n            }\n        }\n        else {\n            if (_doubleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n            }\n        }\n    }\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n    // the slash-character is our 'default base' as we don't\n    // support constructing URIs relative to other URIs. This\n    // also means that we alter and potentially break paths.\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n    switch (scheme) {\n        case 'https':\n        case 'http':\n        case 'file':\n            if (!path) {\n                path = _slash;\n            }\n            else if (path[0] !== _slash) {\n                path = _slash + path;\n            }\n            break;\n    }\n    return path;\n}\nvar _empty = '';\nvar _slash = '/';\nvar _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n *       foo://example.com:8042/over/there?name=ferret#nose\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\n *        |           |            |            |        |\n *     scheme     authority       path        query   fragment\n *        |   _____________________|__\n *       / \\ /                        \\\n *       urn:example:animal:ferret:nose\n */\nvar URI = /** @class */ (function () {\n    /**\n     * @internal\n     */\n    function URI(schemeOrData, authority, path, query, fragment, _strict) {\n        if (typeof schemeOrData === 'object') {\n            this.scheme = schemeOrData.scheme || _empty;\n            this.authority = schemeOrData.authority || _empty;\n            this.path = schemeOrData.path || _empty;\n            this.query = schemeOrData.query || _empty;\n            this.fragment = schemeOrData.fragment || _empty;\n            // no validation because it's this URI\n            // that creates uri components.\n            // _validateUri(this);\n        }\n        else {\n            this.scheme = schemeOrData || _empty;\n            this.authority = authority || _empty;\n            this.path = _referenceResolution(this.scheme, path || _empty);\n            this.query = query || _empty;\n            this.fragment = fragment || _empty;\n            _validateUri(this, _strict);\n        }\n    }\n    URI.isUri = function (thing) {\n        if (thing instanceof URI) {\n            return true;\n        }\n        if (!thing) {\n            return false;\n        }\n        return typeof thing.authority === 'string'\n            && typeof thing.fragment === 'string'\n            && typeof thing.path === 'string'\n            && typeof thing.query === 'string'\n            && typeof thing.scheme === 'string'\n            && typeof thing.fsPath === 'function'\n            && typeof thing.with === 'function'\n            && typeof thing.toString === 'function';\n    };\n    Object.defineProperty(URI.prototype, \"fsPath\", {\n        // ---- filesystem path -----------------------\n        /**\n         * Returns a string representing the corresponding file system path of this URI.\n         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n         * platform specific path separator.\n         *\n         * * Will *not* validate the path for invalid characters and semantics.\n         * * Will *not* look at the scheme of this URI.\n         * * The result shall *not* be used for display purposes but for accessing a file on disk.\n         *\n         *\n         * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n         *\n         * ```ts\n            const u = URI.parse('file://server/c$/folder/file.txt')\n            u.authority === 'server'\n            u.path === '/shares/c$/file.txt'\n            u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n        ```\n         *\n         * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n         * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n         * with URIs that represent files on disk (`file` scheme).\n         */\n        get: function () {\n            // if (this.scheme !== 'file') {\n            // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n            // }\n            return _makeFsPath(this);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // ---- modify to new -------------------------\n    URI.prototype.with = function (change) {\n        if (!change) {\n            return this;\n        }\n        var scheme = change.scheme, authority = change.authority, path = change.path, query = change.query, fragment = change.fragment;\n        if (scheme === undefined) {\n            scheme = this.scheme;\n        }\n        else if (scheme === null) {\n            scheme = _empty;\n        }\n        if (authority === undefined) {\n            authority = this.authority;\n        }\n        else if (authority === null) {\n            authority = _empty;\n        }\n        if (path === undefined) {\n            path = this.path;\n        }\n        else if (path === null) {\n            path = _empty;\n        }\n        if (query === undefined) {\n            query = this.query;\n        }\n        else if (query === null) {\n            query = _empty;\n        }\n        if (fragment === undefined) {\n            fragment = this.fragment;\n        }\n        else if (fragment === null) {\n            fragment = _empty;\n        }\n        if (scheme === this.scheme\n            && authority === this.authority\n            && path === this.path\n            && query === this.query\n            && fragment === this.fragment) {\n            return this;\n        }\n        return new _URI(scheme, authority, path, query, fragment);\n    };\n    // ---- parse & validate ------------------------\n    /**\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\n     * `file:///usr/home`, or `scheme:with/path`.\n     *\n     * @param value A string which represents an URI (see `URI#toString`).\n     */\n    URI.parse = function (value, _strict) {\n        if (_strict === void 0) { _strict = false; }\n        var match = _regexp.exec(value);\n        if (!match) {\n            return new _URI(_empty, _empty, _empty, _empty, _empty);\n        }\n        return new _URI(match[2] || _empty, decodeURIComponent(match[4] || _empty), decodeURIComponent(match[5] || _empty), decodeURIComponent(match[7] || _empty), decodeURIComponent(match[9] || _empty), _strict);\n    };\n    /**\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\n     *\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n     * `URI.parse('file://' + path)` because the path might contain characters that are\n     * interpreted (# and ?). See the following sample:\n     * ```ts\n    const good = URI.file('/coding/c#/project1');\n    good.scheme === 'file';\n    good.path === '/coding/c#/project1';\n    good.fragment === '';\n    const bad = URI.parse('file://' + '/coding/c#/project1');\n    bad.scheme === 'file';\n    bad.path === '/coding/c'; // path is now broken\n    bad.fragment === '/project1';\n    ```\n     *\n     * @param path A file system path (see `URI#fsPath`)\n     */\n    URI.file = function (path) {\n        var authority = _empty;\n        // normalize to fwd-slashes on windows,\n        // on other systems bwd-slashes are valid\n        // filename character, eg /f\\oo/ba\\r.txt\n        if (isWindows) {\n            path = path.replace(/\\\\/g, _slash);\n        }\n        // check for authority as used in UNC shares\n        // or use the path as given\n        if (path[0] === _slash && path[1] === _slash) {\n            var idx = path.indexOf(_slash, 2);\n            if (idx === -1) {\n                authority = path.substring(2);\n                path = _slash;\n            }\n            else {\n                authority = path.substring(2, idx);\n                path = path.substring(idx) || _slash;\n            }\n        }\n        return new _URI('file', authority, path, _empty, _empty);\n    };\n    URI.from = function (components) {\n        return new _URI(components.scheme, components.authority, components.path, components.query, components.fragment);\n    };\n    // ---- printing/externalize ---------------------------\n    /**\n     * Creates a string representation for this URI. It's guaranteed that calling\n     * `URI.parse` with the result of this function creates an URI which is equal\n     * to this URI.\n     *\n     * * The result shall *not* be used for display purposes but for externalization or transport.\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\n     * ignore the scheme-specific encoding rules.\n     *\n     * @param skipEncoding Do not encode the result, default is `false`\n     */\n    URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        return _asFormatted(this, skipEncoding);\n    };\n    URI.prototype.toJSON = function () {\n        return this;\n    };\n    URI.revive = function (data) {\n        if (!data) {\n            return data;\n        }\n        else if (data instanceof URI) {\n            return data;\n        }\n        else {\n            var result = new _URI(data);\n            result._fsPath = data.fsPath;\n            result._formatted = data.external;\n            return result;\n        }\n    };\n    return URI;\n}());\nexport { URI };\n// tslint:disable-next-line:class-name\nvar _URI = /** @class */ (function (_super) {\n    __extends(_URI, _super);\n    function _URI() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this._formatted = null;\n        _this._fsPath = null;\n        return _this;\n    }\n    Object.defineProperty(_URI.prototype, \"fsPath\", {\n        get: function () {\n            if (!this._fsPath) {\n                this._fsPath = _makeFsPath(this);\n            }\n            return this._fsPath;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    _URI.prototype.toString = function (skipEncoding) {\n        if (skipEncoding === void 0) { skipEncoding = false; }\n        if (!skipEncoding) {\n            if (!this._formatted) {\n                this._formatted = _asFormatted(this, false);\n            }\n            return this._formatted;\n        }\n        else {\n            // we don't cache that\n            return _asFormatted(this, true);\n        }\n    };\n    _URI.prototype.toJSON = function () {\n        var res = {\n            $mid: 1\n        };\n        // cached state\n        if (this._fsPath) {\n            res.fsPath = this._fsPath;\n        }\n        if (this._formatted) {\n            res.external = this._formatted;\n        }\n        // uri components\n        if (this.path) {\n            res.path = this.path;\n        }\n        if (this.scheme) {\n            res.scheme = this.scheme;\n        }\n        if (this.authority) {\n            res.authority = this.authority;\n        }\n        if (this.query) {\n            res.query = this.query;\n        }\n        if (this.fragment) {\n            res.fragment = this.fragment;\n        }\n        return res;\n    };\n    return _URI;\n}(URI));\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nvar encodeTable = (_a = {},\n    _a[58 /* Colon */] = '%3A',\n    _a[47 /* Slash */] = '%2F',\n    _a[63 /* QuestionMark */] = '%3F',\n    _a[35 /* Hash */] = '%23',\n    _a[91 /* OpenSquareBracket */] = '%5B',\n    _a[93 /* CloseSquareBracket */] = '%5D',\n    _a[64 /* AtSign */] = '%40',\n    _a[33 /* ExclamationMark */] = '%21',\n    _a[36 /* DollarSign */] = '%24',\n    _a[38 /* Ampersand */] = '%26',\n    _a[39 /* SingleQuote */] = '%27',\n    _a[40 /* OpenParen */] = '%28',\n    _a[41 /* CloseParen */] = '%29',\n    _a[42 /* Asterisk */] = '%2A',\n    _a[43 /* Plus */] = '%2B',\n    _a[44 /* Comma */] = '%2C',\n    _a[59 /* Semicolon */] = '%3B',\n    _a[61 /* Equals */] = '%3D',\n    _a[32 /* Space */] = '%20',\n    _a);\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\n    var res = undefined;\n    var nativeEncodePos = -1;\n    for (var pos = 0; pos < uriComponent.length; pos++) {\n        var code = uriComponent.charCodeAt(pos);\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\n            || code === 45 /* Dash */\n            || code === 46 /* Period */\n            || code === 95 /* Underline */\n            || code === 126 /* Tilde */\n            || (allowSlash && code === 47 /* Slash */)) {\n            // check if we are delaying native encode\n            if (nativeEncodePos !== -1) {\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                nativeEncodePos = -1;\n            }\n            // check if we write into a new string (by default we try to return the param)\n            if (res !== undefined) {\n                res += uriComponent.charAt(pos);\n            }\n        }\n        else {\n            // encoding needed, we need to allocate a new string\n            if (res === undefined) {\n                res = uriComponent.substr(0, pos);\n            }\n            // check with default table first\n            var escaped = encodeTable[code];\n            if (escaped !== undefined) {\n                // check if we are delaying native encode\n                if (nativeEncodePos !== -1) {\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                    nativeEncodePos = -1;\n                }\n                // append escaped variant to result\n                res += escaped;\n            }\n            else if (nativeEncodePos === -1) {\n                // use native encode only when needed\n                nativeEncodePos = pos;\n            }\n        }\n    }\n    if (nativeEncodePos !== -1) {\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n    }\n    return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n    var res = undefined;\n    for (var pos = 0; pos < path.length; pos++) {\n        var code = path.charCodeAt(pos);\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\n            if (res === undefined) {\n                res = path.substr(0, pos);\n            }\n            res += encodeTable[code];\n        }\n        else {\n            if (res !== undefined) {\n                res += path[pos];\n            }\n        }\n    }\n    return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n */\nfunction _makeFsPath(uri) {\n    var value;\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n        // unc path: file://shares/c$/far/boo\n        value = \"//\" + uri.authority + uri.path;\n    }\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\n        && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */)\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\n        // windows drive letter: file:///c:/far/boo\n        value = uri.path[1].toLowerCase() + uri.path.substr(2);\n    }\n    else {\n        // other path\n        value = uri.path;\n    }\n    if (isWindows) {\n        value = value.replace(/\\//g, '\\\\');\n    }\n    return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n    var encoder = !skipEncoding\n        ? encodeURIComponentFast\n        : encodeURIComponentMinimal;\n    var res = '';\n    var scheme = uri.scheme, authority = uri.authority, path = uri.path, query = uri.query, fragment = uri.fragment;\n    if (scheme) {\n        res += scheme;\n        res += ':';\n    }\n    if (authority || scheme === 'file') {\n        res += _slash;\n        res += _slash;\n    }\n    if (authority) {\n        var idx = authority.indexOf('@');\n        if (idx !== -1) {\n            // <user>@<auth>\n            var userinfo = authority.substr(0, idx);\n            authority = authority.substr(idx + 1);\n            idx = userinfo.indexOf(':');\n            if (idx === -1) {\n                res += encoder(userinfo, false);\n            }\n            else {\n                // <user>:<pass>@<auth>\n                res += encoder(userinfo.substr(0, idx), false);\n                res += ':';\n                res += encoder(userinfo.substr(idx + 1), false);\n            }\n            res += '@';\n        }\n        authority = authority.toLowerCase();\n        idx = authority.indexOf(':');\n        if (idx === -1) {\n            res += encoder(authority, false);\n        }\n        else {\n            // <auth>:<port>\n            res += encoder(authority.substr(0, idx), false);\n            res += authority.substr(idx);\n        }\n    }\n    if (path) {\n        // lower-case windows drive letters in /C:/fff or C:/fff\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\n            var code = path.charCodeAt(1);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = \"/\" + String.fromCharCode(code + 32) + \":\" + path.substr(3); // \"/c:\".length === 3\n            }\n        }\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\n            var code = path.charCodeAt(0);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = String.fromCharCode(code + 32) + \":\" + path.substr(2); // \"/c:\".length === 3\n            }\n        }\n        // encode the rest of the path\n        res += encoder(path, true);\n    }\n    if (query) {\n        res += '?';\n        res += encoder(query, false);\n    }\n    if (fragment) {\n        res += '#';\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\n    }\n    return res;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nvar Position = /** @class */ (function () {\n    function Position(lineNumber, column) {\n        this.lineNumber = lineNumber;\n        this.column = column;\n    }\n    /**\n     * Create a new postion from this position.\n     *\n     * @param newLineNumber new line number\n     * @param newColumn new column\n     */\n    Position.prototype.with = function (newLineNumber, newColumn) {\n        if (newLineNumber === void 0) { newLineNumber = this.lineNumber; }\n        if (newColumn === void 0) { newColumn = this.column; }\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\n            return this;\n        }\n        else {\n            return new Position(newLineNumber, newColumn);\n        }\n    };\n    /**\n     * Derive a new position from this position.\n     *\n     * @param deltaLineNumber line number delta\n     * @param deltaColumn column delta\n     */\n    Position.prototype.delta = function (deltaLineNumber, deltaColumn) {\n        if (deltaLineNumber === void 0) { deltaLineNumber = 0; }\n        if (deltaColumn === void 0) { deltaColumn = 0; }\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n    };\n    /**\n     * Test if this position equals other position\n     */\n    Position.prototype.equals = function (other) {\n        return Position.equals(this, other);\n    };\n    /**\n     * Test if position `a` equals position `b`\n     */\n    Position.equals = function (a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.lineNumber === b.lineNumber &&\n            a.column === b.column);\n    };\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be false.\n     */\n    Position.prototype.isBefore = function (other) {\n        return Position.isBefore(this, other);\n    };\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be false.\n     */\n    Position.isBefore = function (a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column < b.column;\n    };\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be true.\n     */\n    Position.prototype.isBeforeOrEqual = function (other) {\n        return Position.isBeforeOrEqual(this, other);\n    };\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be true.\n     */\n    Position.isBeforeOrEqual = function (a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column <= b.column;\n    };\n    /**\n     * A function that compares positions, useful for sorting\n     */\n    Position.compare = function (a, b) {\n        var aLineNumber = a.lineNumber | 0;\n        var bLineNumber = b.lineNumber | 0;\n        if (aLineNumber === bLineNumber) {\n            var aColumn = a.column | 0;\n            var bColumn = b.column | 0;\n            return aColumn - bColumn;\n        }\n        return aLineNumber - bLineNumber;\n    };\n    /**\n     * Clone this position.\n     */\n    Position.prototype.clone = function () {\n        return new Position(this.lineNumber, this.column);\n    };\n    /**\n     * Convert to a human-readable representation.\n     */\n    Position.prototype.toString = function () {\n        return '(' + this.lineNumber + ',' + this.column + ')';\n    };\n    // ---\n    /**\n     * Create a `Position` from an `IPosition`.\n     */\n    Position.lift = function (pos) {\n        return new Position(pos.lineNumber, pos.column);\n    };\n    /**\n     * Test if `obj` is an `IPosition`.\n     */\n    Position.isIPosition = function (obj) {\n        return (obj\n            && (typeof obj.lineNumber === 'number')\n            && (typeof obj.column === 'number'));\n    };\n    return Position;\n}());\nexport { Position };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nvar Range = /** @class */ (function () {\n    function Range(startLineNumber, startColumn, endLineNumber, endColumn) {\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n            this.startLineNumber = endLineNumber;\n            this.startColumn = endColumn;\n            this.endLineNumber = startLineNumber;\n            this.endColumn = startColumn;\n        }\n        else {\n            this.startLineNumber = startLineNumber;\n            this.startColumn = startColumn;\n            this.endLineNumber = endLineNumber;\n            this.endColumn = endColumn;\n        }\n    }\n    /**\n     * Test if this range is empty.\n     */\n    Range.prototype.isEmpty = function () {\n        return Range.isEmpty(this);\n    };\n    /**\n     * Test if `range` is empty.\n     */\n    Range.isEmpty = function (range) {\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n    };\n    /**\n     * Test if position is in this range. If the position is at the edges, will return true.\n     */\n    Range.prototype.containsPosition = function (position) {\n        return Range.containsPosition(this, position);\n    };\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\n     */\n    Range.containsPosition = function (range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n            return false;\n        }\n        return true;\n    };\n    /**\n     * Test if range is in this range. If the range is equal to this range, will return true.\n     */\n    Range.prototype.containsRange = function (range) {\n        return Range.containsRange(this, range);\n    };\n    /**\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n     */\n    Range.containsRange = function (range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n            return false;\n        }\n        return true;\n    };\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    Range.prototype.plusRange = function (range) {\n        return Range.plusRange(this, range);\n    };\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    Range.plusRange = function (a, b) {\n        var startLineNumber;\n        var startColumn;\n        var endLineNumber;\n        var endColumn;\n        if (b.startLineNumber < a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = b.startColumn;\n        }\n        else if (b.startLineNumber === a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = Math.min(b.startColumn, a.startColumn);\n        }\n        else {\n            startLineNumber = a.startLineNumber;\n            startColumn = a.startColumn;\n        }\n        if (b.endLineNumber > a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = b.endColumn;\n        }\n        else if (b.endLineNumber === a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = Math.max(b.endColumn, a.endColumn);\n        }\n        else {\n            endLineNumber = a.endLineNumber;\n            endColumn = a.endColumn;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    };\n    /**\n     * A intersection of the two ranges.\n     */\n    Range.prototype.intersectRanges = function (range) {\n        return Range.intersectRanges(this, range);\n    };\n    /**\n     * A intersection of the two ranges.\n     */\n    Range.intersectRanges = function (a, b) {\n        var resultStartLineNumber = a.startLineNumber;\n        var resultStartColumn = a.startColumn;\n        var resultEndLineNumber = a.endLineNumber;\n        var resultEndColumn = a.endColumn;\n        var otherStartLineNumber = b.startLineNumber;\n        var otherStartColumn = b.startColumn;\n        var otherEndLineNumber = b.endLineNumber;\n        var otherEndColumn = b.endColumn;\n        if (resultStartLineNumber < otherStartLineNumber) {\n            resultStartLineNumber = otherStartLineNumber;\n            resultStartColumn = otherStartColumn;\n        }\n        else if (resultStartLineNumber === otherStartLineNumber) {\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n        }\n        if (resultEndLineNumber > otherEndLineNumber) {\n            resultEndLineNumber = otherEndLineNumber;\n            resultEndColumn = otherEndColumn;\n        }\n        else if (resultEndLineNumber === otherEndLineNumber) {\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n        }\n        // Check if selection is now empty\n        if (resultStartLineNumber > resultEndLineNumber) {\n            return null;\n        }\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n            return null;\n        }\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n    };\n    /**\n     * Test if this range equals other.\n     */\n    Range.prototype.equalsRange = function (other) {\n        return Range.equalsRange(this, other);\n    };\n    /**\n     * Test if range `a` equals `b`.\n     */\n    Range.equalsRange = function (a, b) {\n        return (!!a &&\n            !!b &&\n            a.startLineNumber === b.startLineNumber &&\n            a.startColumn === b.startColumn &&\n            a.endLineNumber === b.endLineNumber &&\n            a.endColumn === b.endColumn);\n    };\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    Range.prototype.getEndPosition = function () {\n        return new Position(this.endLineNumber, this.endColumn);\n    };\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    Range.prototype.getStartPosition = function () {\n        return new Position(this.startLineNumber, this.startColumn);\n    };\n    /**\n     * Transform to a user presentable string representation.\n     */\n    Range.prototype.toString = function () {\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n    };\n    /**\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n     */\n    Range.prototype.setEndPosition = function (endLineNumber, endColumn) {\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n    };\n    /**\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n     */\n    Range.prototype.setStartPosition = function (startLineNumber, startColumn) {\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n    };\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    Range.prototype.collapseToStart = function () {\n        return Range.collapseToStart(this);\n    };\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    Range.collapseToStart = function (range) {\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n    };\n    // ---\n    Range.fromPositions = function (start, end) {\n        if (end === void 0) { end = start; }\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n    };\n    Range.lift = function (range) {\n        if (!range) {\n            return null;\n        }\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n    };\n    /**\n     * Test if `obj` is an `IRange`.\n     */\n    Range.isIRange = function (obj) {\n        return (obj\n            && (typeof obj.startLineNumber === 'number')\n            && (typeof obj.startColumn === 'number')\n            && (typeof obj.endLineNumber === 'number')\n            && (typeof obj.endColumn === 'number'));\n    };\n    /**\n     * Test if the two ranges are touching in any way.\n     */\n    Range.areIntersectingOrTouching = function (a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    };\n    /**\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n     */\n    Range.areIntersecting = function (a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    };\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the startPosition and then on the endPosition\n     */\n    Range.compareRangesUsingStarts = function (a, b) {\n        if (a && b) {\n            var aStartLineNumber = a.startLineNumber | 0;\n            var bStartLineNumber = b.startLineNumber | 0;\n            if (aStartLineNumber === bStartLineNumber) {\n                var aStartColumn = a.startColumn | 0;\n                var bStartColumn = b.startColumn | 0;\n                if (aStartColumn === bStartColumn) {\n                    var aEndLineNumber = a.endLineNumber | 0;\n                    var bEndLineNumber = b.endLineNumber | 0;\n                    if (aEndLineNumber === bEndLineNumber) {\n                        var aEndColumn = a.endColumn | 0;\n                        var bEndColumn = b.endColumn | 0;\n                        return aEndColumn - bEndColumn;\n                    }\n                    return aEndLineNumber - bEndLineNumber;\n                }\n                return aStartColumn - bStartColumn;\n            }\n            return aStartLineNumber - bStartLineNumber;\n        }\n        var aExists = (a ? 1 : 0);\n        var bExists = (b ? 1 : 0);\n        return aExists - bExists;\n    };\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the endPosition and then on the startPosition\n     */\n    Range.compareRangesUsingEnds = function (a, b) {\n        if (a.endLineNumber === b.endLineNumber) {\n            if (a.endColumn === b.endColumn) {\n                if (a.startLineNumber === b.startLineNumber) {\n                    return a.startColumn - b.startColumn;\n                }\n                return a.startLineNumber - b.startLineNumber;\n            }\n            return a.endColumn - b.endColumn;\n        }\n        return a.endLineNumber - b.endLineNumber;\n    };\n    /**\n     * Test if the range spans multiple lines.\n     */\n    Range.spansMultipleLines = function (range) {\n        return range.endLineNumber > range.startLineNumber;\n    };\n    return Range;\n}());\nexport { Range };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * The empty string.\n */\nexport var empty = '';\nexport function isFalsyOrWhitespace(str) {\n    if (!str || typeof str !== 'string') {\n        return true;\n    }\n    return str.trim().length === 0;\n}\n/**\n * @returns the provided number with the given number of preceding zeros.\n */\nexport function pad(n, l, char) {\n    if (char === void 0) { char = '0'; }\n    var str = '' + n;\n    var r = [str];\n    for (var i = str.length; i < l; i++) {\n        r.push(char);\n    }\n    return r.reverse().join('');\n}\nvar _formatRegexp = /{(\\d+)}/g;\n/**\n * Helper to produce a string with a variable number of arguments. Insert variable segments\n * into the string using the {n} notation where N is the index of the argument following the string.\n * @param value string to which formatting is applied\n * @param args replacements for {n}-entries\n */\nexport function format(value) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (args.length === 0) {\n        return value;\n    }\n    return value.replace(_formatRegexp, function (match, group) {\n        var idx = parseInt(group, 10);\n        return isNaN(idx) || idx < 0 || idx >= args.length ?\n            match :\n            args[idx];\n    });\n}\n/**\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\n * being used e.g. in HTMLElement.innerHTML.\n */\nexport function escape(html) {\n    return html.replace(/[<>&]/g, function (match) {\n        switch (match) {\n            case '<': return '&lt;';\n            case '>': return '&gt;';\n            case '&': return '&amp;';\n            default: return match;\n        }\n    });\n}\n/**\n * Escapes regular expression characters in a given string\n */\nexport function escapeRegExpCharacters(value) {\n    return value.replace(/[\\-\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)\\#]/g, '\\\\$&');\n}\n/**\n * Removes all occurrences of needle from the beginning and end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim (default is a blank)\n */\nexport function trim(haystack, needle) {\n    if (needle === void 0) { needle = ' '; }\n    var trimmed = ltrim(haystack, needle);\n    return rtrim(trimmed, needle);\n}\n/**\n * Removes all occurrences of needle from the beginning of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function ltrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    var needleLen = needle.length;\n    if (needleLen === 0 || haystack.length === 0) {\n        return haystack;\n    }\n    var offset = 0;\n    while (haystack.indexOf(needle, offset) === offset) {\n        offset = offset + needleLen;\n    }\n    return haystack.substring(offset);\n}\n/**\n * Removes all occurrences of needle from the end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function rtrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    var needleLen = needle.length, haystackLen = haystack.length;\n    if (needleLen === 0 || haystackLen === 0) {\n        return haystack;\n    }\n    var offset = haystackLen, idx = -1;\n    while (true) {\n        idx = haystack.lastIndexOf(needle, offset - 1);\n        if (idx === -1 || idx + needleLen !== offset) {\n            break;\n        }\n        if (idx === 0) {\n            return '';\n        }\n        offset = idx;\n    }\n    return haystack.substring(0, offset);\n}\nexport function convertSimple2RegExpPattern(pattern) {\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\n/**\n * Determines if haystack starts with needle.\n */\nexport function startsWith(haystack, needle) {\n    if (haystack.length < needle.length) {\n        return false;\n    }\n    if (haystack === needle) {\n        return true;\n    }\n    for (var i = 0; i < needle.length; i++) {\n        if (haystack[i] !== needle[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Determines if haystack ends with needle.\n */\nexport function endsWith(haystack, needle) {\n    var diff = haystack.length - needle.length;\n    if (diff > 0) {\n        return haystack.indexOf(needle, diff) === diff;\n    }\n    else if (diff === 0) {\n        return haystack === needle;\n    }\n    else {\n        return false;\n    }\n}\nexport function createRegExp(searchString, isRegex, options) {\n    if (options === void 0) { options = {}; }\n    if (!searchString) {\n        throw new Error('Cannot create regex from empty string');\n    }\n    if (!isRegex) {\n        searchString = escapeRegExpCharacters(searchString);\n    }\n    if (options.wholeWord) {\n        if (!/\\B/.test(searchString.charAt(0))) {\n            searchString = '\\\\b' + searchString;\n        }\n        if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n            searchString = searchString + '\\\\b';\n        }\n    }\n    var modifiers = '';\n    if (options.global) {\n        modifiers += 'g';\n    }\n    if (!options.matchCase) {\n        modifiers += 'i';\n    }\n    if (options.multiline) {\n        modifiers += 'm';\n    }\n    if (options.unicode) {\n        modifiers += 'u';\n    }\n    return new RegExp(searchString, modifiers);\n}\nexport function regExpLeadsToEndlessLoop(regexp) {\n    // Exit early if it's one of these special cases which are meant to match\n    // against an empty string\n    if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n        return false;\n    }\n    // We check against an empty string. If the regular expression doesn't advance\n    // (e.g. ends in an endless loop) it will match an empty string.\n    var match = regexp.exec('');\n    return !!(match && regexp.lastIndex === 0);\n}\nexport function regExpFlags(regexp) {\n    return (regexp.global ? 'g' : '')\n        + (regexp.ignoreCase ? 'i' : '')\n        + (regexp.multiline ? 'm' : '')\n        + (regexp.unicode ? 'u' : '');\n}\n/**\n * Returns first index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function firstNonWhitespaceIndex(str) {\n    for (var i = 0, len = str.length; i < len; i++) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\n/**\n * Returns the leading whitespace of the string.\n * If the string contains only whitespaces, returns entire string\n */\nexport function getLeadingWhitespace(str, start, end) {\n    if (start === void 0) { start = 0; }\n    if (end === void 0) { end = str.length; }\n    for (var i = start; i < end; i++) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return str.substring(start, i);\n        }\n    }\n    return str.substring(start, end);\n}\n/**\n * Returns last index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function lastNonWhitespaceIndex(str, startIndex) {\n    if (startIndex === void 0) { startIndex = str.length - 1; }\n    for (var i = startIndex; i >= 0; i--) {\n        var chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\nexport function compare(a, b) {\n    if (a < b) {\n        return -1;\n    }\n    else if (a > b) {\n        return 1;\n    }\n    else {\n        return 0;\n    }\n}\nexport function isLowerAsciiLetter(code) {\n    return code >= 97 /* a */ && code <= 122 /* z */;\n}\nexport function isUpperAsciiLetter(code) {\n    return code >= 65 /* A */ && code <= 90 /* Z */;\n}\nfunction isAsciiLetter(code) {\n    return isLowerAsciiLetter(code) || isUpperAsciiLetter(code);\n}\nexport function equalsIgnoreCase(a, b) {\n    var len1 = a ? a.length : 0;\n    var len2 = b ? b.length : 0;\n    if (len1 !== len2) {\n        return false;\n    }\n    return doEqualsIgnoreCase(a, b);\n}\nfunction doEqualsIgnoreCase(a, b, stopAt) {\n    if (stopAt === void 0) { stopAt = a.length; }\n    if (typeof a !== 'string' || typeof b !== 'string') {\n        return false;\n    }\n    for (var i = 0; i < stopAt; i++) {\n        var codeA = a.charCodeAt(i);\n        var codeB = b.charCodeAt(i);\n        if (codeA === codeB) {\n            continue;\n        }\n        // a-z A-Z\n        if (isAsciiLetter(codeA) && isAsciiLetter(codeB)) {\n            var diff = Math.abs(codeA - codeB);\n            if (diff !== 0 && diff !== 32) {\n                return false;\n            }\n        }\n        // Any other charcode\n        else {\n            if (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\nexport function startsWithIgnoreCase(str, candidate) {\n    var candidateLength = candidate.length;\n    if (candidate.length > str.length) {\n        return false;\n    }\n    return doEqualsIgnoreCase(str, candidate, candidateLength);\n}\n/**\n * @returns the length of the common prefix of the two strings.\n */\nexport function commonPrefixLength(a, b) {\n    var i, len = Math.min(a.length, b.length);\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(i) !== b.charCodeAt(i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * @returns the length of the common suffix of the two strings.\n */\nexport function commonSuffixLength(a, b) {\n    var i, len = Math.min(a.length, b.length);\n    var aLastIndex = a.length - 1;\n    var bLastIndex = b.length - 1;\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n            return i;\n        }\n    }\n    return len;\n}\n// --- unicode\n// http://en.wikipedia.org/wiki/Surrogate_pair\n// Returns the code point starting at a specified index in a string\n// Code points U+0000 to U+D7FF and U+E000 to U+FFFF are represented on a single character\n// Code points U+10000 to U+10FFFF are represented on two consecutive characters\n//export function getUnicodePoint(str:string, index:number, len:number):number {\n//\tlet chrCode = str.charCodeAt(index);\n//\tif (0xD800 <= chrCode && chrCode <= 0xDBFF && index + 1 < len) {\n//\t\tlet nextChrCode = str.charCodeAt(index + 1);\n//\t\tif (0xDC00 <= nextChrCode && nextChrCode <= 0xDFFF) {\n//\t\t\treturn (chrCode - 0xD800) << 10 + (nextChrCode - 0xDC00) + 0x10000;\n//\t\t}\n//\t}\n//\treturn chrCode;\n//}\nexport function isHighSurrogate(charCode) {\n    return (0xD800 <= charCode && charCode <= 0xDBFF);\n}\nexport function isLowSurrogate(charCode) {\n    return (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n/**\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-rtl-test.js\n */\nvar CONTAINS_RTL = /(?:[\\u05BE\\u05C0\\u05C3\\u05C6\\u05D0-\\u05F4\\u0608\\u060B\\u060D\\u061B-\\u064A\\u066D-\\u066F\\u0671-\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1-\\u07EA\\u07F4\\u07F5\\u07FA-\\u0815\\u081A\\u0824\\u0828\\u0830-\\u0858\\u085E-\\u08BD\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFD3D\\uFD50-\\uFDFC\\uFE70-\\uFEFC]|\\uD802[\\uDC00-\\uDD1B\\uDD20-\\uDE00\\uDE10-\\uDE33\\uDE40-\\uDEE4\\uDEEB-\\uDF35\\uDF40-\\uDFFF]|\\uD803[\\uDC00-\\uDCFF]|\\uD83A[\\uDC00-\\uDCCF\\uDD00-\\uDD43\\uDD50-\\uDFFF]|\\uD83B[\\uDC00-\\uDEBB])/;\n/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nexport function containsRTL(str) {\n    return CONTAINS_RTL.test(str);\n}\n/**\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-emoji-test.js\n */\nvar CONTAINS_EMOJI = /(?:[\\u231A\\u231B\\u23F0\\u23F3\\u2600-\\u27BF\\u2B50\\u2B55]|\\uD83C[\\uDDE6-\\uDDFF\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDE4F\\uDE80-\\uDEF8]|\\uD83E[\\uDD00-\\uDDE6])/;\nexport function containsEmoji(str) {\n    return CONTAINS_EMOJI.test(str);\n}\nvar IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\n/**\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\n */\nexport function isBasicASCII(str) {\n    return IS_BASIC_ASCII.test(str);\n}\nexport function containsFullWidthCharacter(str) {\n    for (var i = 0, len = str.length; i < len; i++) {\n        if (isFullWidthCharacter(str.charCodeAt(i))) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function isFullWidthCharacter(charCode) {\n    // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n    // http://jrgraphix.net/research/unicode_blocks.php\n    //          2E80 — 2EFF   CJK Radicals Supplement\n    //          2F00 — 2FDF   Kangxi Radicals\n    //          2FF0 — 2FFF   Ideographic Description Characters\n    //          3000 — 303F   CJK Symbols and Punctuation\n    //          3040 — 309F   Hiragana\n    //          30A0 — 30FF   Katakana\n    //          3100 — 312F   Bopomofo\n    //          3130 — 318F   Hangul Compatibility Jamo\n    //          3190 — 319F   Kanbun\n    //          31A0 — 31BF   Bopomofo Extended\n    //          31F0 — 31FF   Katakana Phonetic Extensions\n    //          3200 — 32FF   Enclosed CJK Letters and Months\n    //          3300 — 33FF   CJK Compatibility\n    //          3400 — 4DBF   CJK Unified Ideographs Extension A\n    //          4DC0 — 4DFF   Yijing Hexagram Symbols\n    //          4E00 — 9FFF   CJK Unified Ideographs\n    //          A000 — A48F   Yi Syllables\n    //          A490 — A4CF   Yi Radicals\n    //          AC00 — D7AF   Hangul Syllables\n    // [IGNORE] D800 — DB7F   High Surrogates\n    // [IGNORE] DB80 — DBFF   High Private Use Surrogates\n    // [IGNORE] DC00 — DFFF   Low Surrogates\n    // [IGNORE] E000 — F8FF   Private Use Area\n    //          F900 — FAFF   CJK Compatibility Ideographs\n    // [IGNORE] FB00 — FB4F   Alphabetic Presentation Forms\n    // [IGNORE] FB50 — FDFF   Arabic Presentation Forms-A\n    // [IGNORE] FE00 — FE0F   Variation Selectors\n    // [IGNORE] FE20 — FE2F   Combining Half Marks\n    // [IGNORE] FE30 — FE4F   CJK Compatibility Forms\n    // [IGNORE] FE50 — FE6F   Small Form Variants\n    // [IGNORE] FE70 — FEFF   Arabic Presentation Forms-B\n    //          FF00 — FFEF   Halfwidth and Fullwidth Forms\n    //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n    //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n    // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul\n    // [IGNORE] FFF0 — FFFF   Specials\n    charCode = +charCode; // @perf\n    return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\n        || (charCode >= 0xF900 && charCode <= 0xFAFF)\n        || (charCode >= 0xFF01 && charCode <= 0xFF5E));\n}\n// -- UTF-8 BOM\nexport var UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);\nexport function startsWithUTF8BOM(str) {\n    return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);\n}\nexport function safeBtoa(str) {\n    return btoa(encodeURIComponent(str)); // we use encodeURIComponent because btoa fails for non Latin 1 values\n}\nexport function repeat(s, count) {\n    var result = '';\n    for (var i = 0; i < count; i++) {\n        result += s;\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LcsDiff } from '../../../base/common/diff/diff.js';\nimport * as strings from '../../../base/common/strings.js';\nvar MAXIMUM_RUN_TIME = 5000; // 5 seconds\nvar MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n    var diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n    return diffAlgo.ComputeDiff(pretty);\n}\nvar LineMarkerSequence = /** @class */ (function () {\n    function LineMarkerSequence(lines) {\n        var startColumns = [];\n        var endColumns = [];\n        for (var i = 0, length_1 = lines.length; i < length_1; i++) {\n            startColumns[i] = LineMarkerSequence._getFirstNonBlankColumn(lines[i], 1);\n            endColumns[i] = LineMarkerSequence._getLastNonBlankColumn(lines[i], 1);\n        }\n        this._lines = lines;\n        this._startColumns = startColumns;\n        this._endColumns = endColumns;\n    }\n    LineMarkerSequence.prototype.getLength = function () {\n        return this._lines.length;\n    };\n    LineMarkerSequence.prototype.getElementAtIndex = function (i) {\n        return this._lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n    };\n    LineMarkerSequence.prototype.getStartLineNumber = function (i) {\n        return i + 1;\n    };\n    LineMarkerSequence.prototype.getEndLineNumber = function (i) {\n        return i + 1;\n    };\n    LineMarkerSequence._getFirstNonBlankColumn = function (txt, defaultValue) {\n        var r = strings.firstNonWhitespaceIndex(txt);\n        if (r === -1) {\n            return defaultValue;\n        }\n        return r + 1;\n    };\n    LineMarkerSequence._getLastNonBlankColumn = function (txt, defaultValue) {\n        var r = strings.lastNonWhitespaceIndex(txt);\n        if (r === -1) {\n            return defaultValue;\n        }\n        return r + 2;\n    };\n    LineMarkerSequence.prototype.getCharSequence = function (shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n        var charCodes = [];\n        var lineNumbers = [];\n        var columns = [];\n        var len = 0;\n        for (var index = startIndex; index <= endIndex; index++) {\n            var lineContent = this._lines[index];\n            var startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n            var endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n            for (var col = startColumn; col < endColumn; col++) {\n                charCodes[len] = lineContent.charCodeAt(col - 1);\n                lineNumbers[len] = index + 1;\n                columns[len] = col;\n                len++;\n            }\n        }\n        return new CharSequence(charCodes, lineNumbers, columns);\n    };\n    return LineMarkerSequence;\n}());\nvar CharSequence = /** @class */ (function () {\n    function CharSequence(charCodes, lineNumbers, columns) {\n        this._charCodes = charCodes;\n        this._lineNumbers = lineNumbers;\n        this._columns = columns;\n    }\n    CharSequence.prototype.getLength = function () {\n        return this._charCodes.length;\n    };\n    CharSequence.prototype.getElementAtIndex = function (i) {\n        return this._charCodes[i];\n    };\n    CharSequence.prototype.getStartLineNumber = function (i) {\n        return this._lineNumbers[i];\n    };\n    CharSequence.prototype.getStartColumn = function (i) {\n        return this._columns[i];\n    };\n    CharSequence.prototype.getEndLineNumber = function (i) {\n        return this._lineNumbers[i];\n    };\n    CharSequence.prototype.getEndColumn = function (i) {\n        return this._columns[i] + 1;\n    };\n    return CharSequence;\n}());\nvar CharChange = /** @class */ (function () {\n    function CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalStartColumn = originalStartColumn;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.originalEndColumn = originalEndColumn;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedStartColumn = modifiedStartColumn;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.modifiedEndColumn = modifiedEndColumn;\n    }\n    CharChange.createFromDiffChange = function (diffChange, originalCharSequence, modifiedCharSequence) {\n        var originalStartLineNumber;\n        var originalStartColumn;\n        var originalEndLineNumber;\n        var originalEndColumn;\n        var modifiedStartLineNumber;\n        var modifiedStartColumn;\n        var modifiedEndLineNumber;\n        var modifiedEndColumn;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = 0;\n            originalStartColumn = 0;\n            originalEndLineNumber = 0;\n            originalEndColumn = 0;\n        }\n        else {\n            originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n            originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n            originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n            originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = 0;\n            modifiedStartColumn = 0;\n            modifiedEndLineNumber = 0;\n            modifiedEndColumn = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n    };\n    return CharChange;\n}());\nfunction postProcessCharChanges(rawChanges) {\n    if (rawChanges.length <= 1) {\n        return rawChanges;\n    }\n    var result = [rawChanges[0]];\n    var prevChange = result[0];\n    for (var i = 1, len = rawChanges.length; i < len; i++) {\n        var currChange = rawChanges[i];\n        var originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n        var modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n        var matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n            // Merge the current change into the previous one\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n        }\n        else {\n            // Add the current change\n            result.push(currChange);\n            prevChange = currChange;\n        }\n    }\n    return result;\n}\nvar LineChange = /** @class */ (function () {\n    function LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.charChanges = charChanges;\n    }\n    LineChange.createFromDiffResult = function (shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueProcessingPredicate, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n        var originalStartLineNumber;\n        var originalEndLineNumber;\n        var modifiedStartLineNumber;\n        var modifiedEndLineNumber;\n        var charChanges = undefined;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n            originalEndLineNumber = 0;\n        }\n        else {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n            modifiedEndLineNumber = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        if (shouldComputeCharChanges && diffChange.originalLength !== 0 && diffChange.modifiedLength !== 0 && continueProcessingPredicate()) {\n            var originalCharSequence = originalLineSequence.getCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n            var modifiedCharSequence = modifiedLineSequence.getCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            var rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueProcessingPredicate, true);\n            if (shouldPostProcessCharChanges) {\n                rawChanges = postProcessCharChanges(rawChanges);\n            }\n            charChanges = [];\n            for (var i = 0, length_2 = rawChanges.length; i < length_2; i++) {\n                charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n            }\n        }\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n    };\n    return LineChange;\n}());\nvar DiffComputer = /** @class */ (function () {\n    function DiffComputer(originalLines, modifiedLines, opts) {\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n        this.maximumRunTimeMs = MAXIMUM_RUN_TIME;\n        this.originalLines = originalLines;\n        this.modifiedLines = modifiedLines;\n        this.original = new LineMarkerSequence(originalLines);\n        this.modified = new LineMarkerSequence(modifiedLines);\n    }\n    DiffComputer.prototype.computeDiff = function () {\n        if (this.original.getLength() === 1 && this.original.getElementAtIndex(0).length === 0) {\n            // empty original => fast path\n            return [{\n                    originalStartLineNumber: 1,\n                    originalEndLineNumber: 1,\n                    modifiedStartLineNumber: 1,\n                    modifiedEndLineNumber: this.modified.getLength(),\n                    charChanges: [{\n                            modifiedEndColumn: 0,\n                            modifiedEndLineNumber: 0,\n                            modifiedStartColumn: 0,\n                            modifiedStartLineNumber: 0,\n                            originalEndColumn: 0,\n                            originalEndLineNumber: 0,\n                            originalStartColumn: 0,\n                            originalStartLineNumber: 0\n                        }]\n                }];\n        }\n        if (this.modified.getLength() === 1 && this.modified.getElementAtIndex(0).length === 0) {\n            // empty modified => fast path\n            return [{\n                    originalStartLineNumber: 1,\n                    originalEndLineNumber: this.original.getLength(),\n                    modifiedStartLineNumber: 1,\n                    modifiedEndLineNumber: 1,\n                    charChanges: [{\n                            modifiedEndColumn: 0,\n                            modifiedEndLineNumber: 0,\n                            modifiedStartColumn: 0,\n                            modifiedStartLineNumber: 0,\n                            originalEndColumn: 0,\n                            originalEndLineNumber: 0,\n                            originalStartColumn: 0,\n                            originalStartLineNumber: 0\n                        }]\n                }];\n        }\n        this.computationStartTime = (new Date()).getTime();\n        var rawChanges = computeDiff(this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldMakePrettyDiff);\n        // The diff is always computed with ignoring trim whitespace\n        // This ensures we get the prettiest diff\n        if (this.shouldIgnoreTrimWhitespace) {\n            var lineChanges = [];\n            for (var i = 0, length_3 = rawChanges.length; i < length_3; i++) {\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n            }\n            return lineChanges;\n        }\n        // Need to post-process and introduce changes where the trim whitespace is different\n        // Note that we are looping starting at -1 to also cover the lines before the first change\n        var result = [];\n        var originalLineIndex = 0;\n        var modifiedLineIndex = 0;\n        for (var i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n            var nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n            var originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n            var modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n                var originalLine = this.originalLines[originalLineIndex];\n                var modifiedLine = this.modifiedLines[modifiedLineIndex];\n                if (originalLine !== modifiedLine) {\n                    // These lines differ only in trim whitespace\n                    // Check the leading whitespace\n                    {\n                        var originalStartColumn = LineMarkerSequence._getFirstNonBlankColumn(originalLine, 1);\n                        var modifiedStartColumn = LineMarkerSequence._getFirstNonBlankColumn(modifiedLine, 1);\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n                            var originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n                            var modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalStartColumn--;\n                            modifiedStartColumn--;\n                        }\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n                        }\n                    }\n                    // Check the trailing whitespace\n                    {\n                        var originalEndColumn = LineMarkerSequence._getLastNonBlankColumn(originalLine, 1);\n                        var modifiedEndColumn = LineMarkerSequence._getLastNonBlankColumn(modifiedLine, 1);\n                        var originalMaxColumn = originalLine.length + 1;\n                        var modifiedMaxColumn = modifiedLine.length + 1;\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n                            var originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n                            var modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalEndColumn++;\n                            modifiedEndColumn++;\n                        }\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n                        }\n                    }\n                }\n                originalLineIndex++;\n                modifiedLineIndex++;\n            }\n            if (nextChange) {\n                // Emit the actual change\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n                originalLineIndex += nextChange.originalLength;\n                modifiedLineIndex += nextChange.modifiedLength;\n            }\n        }\n        return result;\n    };\n    DiffComputer.prototype._pushTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n            // Merged into previous\n            return;\n        }\n        var charChanges = undefined;\n        if (this.shouldComputeCharChanges) {\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n        }\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n    };\n    DiffComputer.prototype._mergeTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        var len = result.length;\n        if (len === 0) {\n            return false;\n        }\n        var prevChange = result[len - 1];\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n            // Don't merge with inserts/deletes\n            return false;\n        }\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n            prevChange.originalEndLineNumber = originalLineNumber;\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\n            if (this.shouldComputeCharChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        return false;\n    };\n    DiffComputer.prototype._continueProcessingPredicate = function () {\n        if (this.maximumRunTimeMs === 0) {\n            return true;\n        }\n        var now = (new Date()).getTime();\n        return now - this.computationStartTime < this.maximumRunTimeMs;\n    };\n    return DiffComputer;\n}());\nexport { DiffComputer };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar Uint8Matrix = /** @class */ (function () {\n    function Uint8Matrix(rows, cols, defaultValue) {\n        var data = new Uint8Array(rows * cols);\n        for (var i = 0, len = rows * cols; i < len; i++) {\n            data[i] = defaultValue;\n        }\n        this._data = data;\n        this.rows = rows;\n        this.cols = cols;\n    }\n    Uint8Matrix.prototype.get = function (row, col) {\n        return this._data[row * this.cols + col];\n    };\n    Uint8Matrix.prototype.set = function (row, col, value) {\n        this._data[row * this.cols + col] = value;\n    };\n    return Uint8Matrix;\n}());\nexport { Uint8Matrix };\nexport function toUint8(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 255 /* MAX_UINT_8 */) {\n        return 255 /* MAX_UINT_8 */;\n    }\n    return v | 0;\n}\nexport function toUint32(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 4294967295 /* MAX_UINT_32 */) {\n        return 4294967295 /* MAX_UINT_32 */;\n    }\n    return v | 0;\n}\nexport function toUint32Array(arr) {\n    var len = arr.length;\n    var r = new Uint32Array(len);\n    for (var i = 0; i < len; i++) {\n        r[i] = toUint32(arr[i]);\n    }\n    return r;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint32 } from '../core/uint.js';\nvar PrefixSumIndexOfResult = /** @class */ (function () {\n    function PrefixSumIndexOfResult(index, remainder) {\n        this.index = index;\n        this.remainder = remainder;\n    }\n    return PrefixSumIndexOfResult;\n}());\nexport { PrefixSumIndexOfResult };\nvar PrefixSumComputer = /** @class */ (function () {\n    function PrefixSumComputer(values) {\n        this.values = values;\n        this.prefixSum = new Uint32Array(values.length);\n        this.prefixSumValidIndex = new Int32Array(1);\n        this.prefixSumValidIndex[0] = -1;\n    }\n    PrefixSumComputer.prototype.getCount = function () {\n        return this.values.length;\n    };\n    PrefixSumComputer.prototype.insertValues = function (insertIndex, insertValues) {\n        insertIndex = toUint32(insertIndex);\n        var oldValues = this.values;\n        var oldPrefixSum = this.prefixSum;\n        var insertValuesLen = insertValues.length;\n        if (insertValuesLen === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n        this.values.set(insertValues, insertIndex);\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = insertIndex - 1;\n        }\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.changeValue = function (index, value) {\n        index = toUint32(index);\n        value = toUint32(value);\n        if (this.values[index] === value) {\n            return false;\n        }\n        this.values[index] = value;\n        if (index - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = index - 1;\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.removeValues = function (startIndex, cnt) {\n        startIndex = toUint32(startIndex);\n        cnt = toUint32(cnt);\n        var oldValues = this.values;\n        var oldPrefixSum = this.prefixSum;\n        if (startIndex >= oldValues.length) {\n            return false;\n        }\n        var maxCnt = oldValues.length - startIndex;\n        if (cnt >= maxCnt) {\n            cnt = maxCnt;\n        }\n        if (cnt === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length - cnt);\n        this.values.set(oldValues.subarray(0, startIndex), 0);\n        this.values.set(oldValues.subarray(startIndex + cnt), startIndex);\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = startIndex - 1;\n        }\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    };\n    PrefixSumComputer.prototype.getTotalValue = function () {\n        if (this.values.length === 0) {\n            return 0;\n        }\n        return this._getAccumulatedValue(this.values.length - 1);\n    };\n    PrefixSumComputer.prototype.getAccumulatedValue = function (index) {\n        if (index < 0) {\n            return 0;\n        }\n        index = toUint32(index);\n        return this._getAccumulatedValue(index);\n    };\n    PrefixSumComputer.prototype._getAccumulatedValue = function (index) {\n        if (index <= this.prefixSumValidIndex[0]) {\n            return this.prefixSum[index];\n        }\n        var startIndex = this.prefixSumValidIndex[0] + 1;\n        if (startIndex === 0) {\n            this.prefixSum[0] = this.values[0];\n            startIndex++;\n        }\n        if (index >= this.values.length) {\n            index = this.values.length - 1;\n        }\n        for (var i = startIndex; i <= index; i++) {\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n        }\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n        return this.prefixSum[index];\n    };\n    PrefixSumComputer.prototype.getIndexOf = function (accumulatedValue) {\n        accumulatedValue = Math.floor(accumulatedValue); //@perf\n        // Compute all sums (to get a fully valid prefixSum)\n        this.getTotalValue();\n        var low = 0;\n        var high = this.values.length - 1;\n        var mid = 0;\n        var midStop = 0;\n        var midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStop = this.prefixSum[mid];\n            midStart = midStop - this.values[mid];\n            if (accumulatedValue < midStart) {\n                high = mid - 1;\n            }\n            else if (accumulatedValue >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        return new PrefixSumIndexOfResult(mid, accumulatedValue - midStart);\n    };\n    return PrefixSumComputer;\n}());\nexport { PrefixSumComputer };\nvar PrefixSumComputerWithCache = /** @class */ (function () {\n    function PrefixSumComputerWithCache(values) {\n        this._cacheAccumulatedValueStart = 0;\n        this._cache = null;\n        this._actual = new PrefixSumComputer(values);\n        this._bustCache();\n    }\n    PrefixSumComputerWithCache.prototype._bustCache = function () {\n        this._cacheAccumulatedValueStart = 0;\n        this._cache = null;\n    };\n    PrefixSumComputerWithCache.prototype.insertValues = function (insertIndex, insertValues) {\n        if (this._actual.insertValues(insertIndex, insertValues)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.changeValue = function (index, value) {\n        if (this._actual.changeValue(index, value)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.removeValues = function (startIndex, cnt) {\n        if (this._actual.removeValues(startIndex, cnt)) {\n            this._bustCache();\n        }\n    };\n    PrefixSumComputerWithCache.prototype.getTotalValue = function () {\n        return this._actual.getTotalValue();\n    };\n    PrefixSumComputerWithCache.prototype.getAccumulatedValue = function (index) {\n        return this._actual.getAccumulatedValue(index);\n    };\n    PrefixSumComputerWithCache.prototype.getIndexOf = function (accumulatedValue) {\n        accumulatedValue = Math.floor(accumulatedValue); //@perf\n        if (this._cache !== null) {\n            var cacheIndex = accumulatedValue - this._cacheAccumulatedValueStart;\n            if (cacheIndex >= 0 && cacheIndex < this._cache.length) {\n                // Cache hit!\n                return this._cache[cacheIndex];\n            }\n        }\n        // Cache miss!\n        return this._actual.getIndexOf(accumulatedValue);\n    };\n    /**\n     * Gives a hint that a lot of requests are about to come in for these accumulated values.\n     */\n    PrefixSumComputerWithCache.prototype.warmUpCache = function (accumulatedValueStart, accumulatedValueEnd) {\n        var newCache = [];\n        for (var accumulatedValue = accumulatedValueStart; accumulatedValue <= accumulatedValueEnd; accumulatedValue++) {\n            newCache[accumulatedValue - accumulatedValueStart] = this.getIndexOf(accumulatedValue);\n        }\n        this._cache = newCache;\n        this._cacheAccumulatedValueStart = accumulatedValueStart;\n    };\n    return PrefixSumComputerWithCache;\n}());\nexport { PrefixSumComputerWithCache };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from '../core/position.js';\nimport { PrefixSumComputer } from '../viewModel/prefixSumComputer.js';\nvar MirrorTextModel = /** @class */ (function () {\n    function MirrorTextModel(uri, lines, eol, versionId) {\n        this._uri = uri;\n        this._lines = lines;\n        this._eol = eol;\n        this._versionId = versionId;\n        this._lineStarts = null;\n    }\n    MirrorTextModel.prototype.dispose = function () {\n        this._lines.length = 0;\n    };\n    MirrorTextModel.prototype.getText = function () {\n        return this._lines.join(this._eol);\n    };\n    MirrorTextModel.prototype.onEvents = function (e) {\n        if (e.eol && e.eol !== this._eol) {\n            this._eol = e.eol;\n            this._lineStarts = null;\n        }\n        // Update my lines\n        var changes = e.changes;\n        for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {\n            var change = changes_1[_i];\n            this._acceptDeleteRange(change.range);\n            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n        }\n        this._versionId = e.versionId;\n    };\n    MirrorTextModel.prototype._ensureLineStarts = function () {\n        if (!this._lineStarts) {\n            var eolLength = this._eol.length;\n            var linesLength = this._lines.length;\n            var lineStartValues = new Uint32Array(linesLength);\n            for (var i = 0; i < linesLength; i++) {\n                lineStartValues[i] = this._lines[i].length + eolLength;\n            }\n            this._lineStarts = new PrefixSumComputer(lineStartValues);\n        }\n    };\n    /**\n     * All changes to a line's text go through this method\n     */\n    MirrorTextModel.prototype._setLineText = function (lineIndex, newValue) {\n        this._lines[lineIndex] = newValue;\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n        }\n    };\n    MirrorTextModel.prototype._acceptDeleteRange = function (range) {\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            // Delete text on the affected line\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n            return;\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n        // Delete middle lines\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        }\n    };\n    MirrorTextModel.prototype._acceptInsertText = function (position, insertText) {\n        if (insertText.length === 0) {\n            // Nothing to insert\n            return;\n        }\n        var insertLines = insertText.split(/\\r\\n|\\r|\\n/);\n        if (insertLines.length === 1) {\n            // Inserting text on one line\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n                + insertLines[0]\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\n            return;\n        }\n        // Append overflowing text from first line to the end of text to insert\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n        // Delete overflowing text from first line and insert text on first line\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n            + insertLines[0]);\n        // Insert new lines & store lengths\n        var newLengths = new Uint32Array(insertLines.length - 1);\n        for (var i = 1; i < insertLines.length; i++) {\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\n        }\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\n        }\n    };\n    return MirrorTextModel;\n}());\nexport { MirrorTextModel };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords) {\n    if (allowInWords === void 0) { allowInWords = ''; }\n    var source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n    for (var _i = 0, USUAL_WORD_SEPARATORS_1 = USUAL_WORD_SEPARATORS; _i < USUAL_WORD_SEPARATORS_1.length; _i++) {\n        var sep = USUAL_WORD_SEPARATORS_1[_i];\n        if (allowInWords.indexOf(sep) >= 0) {\n            continue;\n        }\n        source += '\\\\' + sep;\n    }\n    source += '\\\\s]+)';\n    return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport var DEFAULT_WORD_REGEXP = createWordRegExp();\nexport function ensureValidWordDefinition(wordDefinition) {\n    var result = DEFAULT_WORD_REGEXP;\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\n        if (!wordDefinition.global) {\n            var flags = 'g';\n            if (wordDefinition.ignoreCase) {\n                flags += 'i';\n            }\n            if (wordDefinition.multiline) {\n                flags += 'm';\n            }\n            if (wordDefinition.unicode) {\n                flags += 'u';\n            }\n            result = new RegExp(wordDefinition.source, flags);\n        }\n        else {\n            result = wordDefinition;\n        }\n    }\n    result.lastIndex = 0;\n    return result;\n}\nfunction getWordAtPosFast(column, wordDefinition, text, textOffset) {\n    // find whitespace enclosed text around column and match from there\n    var pos = column - 1 - textOffset;\n    var start = text.lastIndexOf(' ', pos - 1) + 1;\n    wordDefinition.lastIndex = start;\n    var match;\n    while (match = wordDefinition.exec(text)) {\n        var matchIndex = match.index || 0;\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n            return {\n                word: match[0],\n                startColumn: textOffset + 1 + matchIndex,\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\n            };\n        }\n    }\n    return null;\n}\nfunction getWordAtPosSlow(column, wordDefinition, text, textOffset) {\n    // matches all words starting at the beginning\n    // of the input until it finds a match that encloses\n    // the desired column. slow but correct\n    var pos = column - 1 - textOffset;\n    wordDefinition.lastIndex = 0;\n    var match;\n    while (match = wordDefinition.exec(text)) {\n        var matchIndex = match.index || 0;\n        if (matchIndex > pos) {\n            // |nW -> matched only after the pos\n            return null;\n        }\n        else if (wordDefinition.lastIndex >= pos) {\n            // W|W -> match encloses pos\n            return {\n                word: match[0],\n                startColumn: textOffset + 1 + matchIndex,\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\n            };\n        }\n    }\n    return null;\n}\nexport function getWordAtText(column, wordDefinition, text, textOffset) {\n    // if `words` can contain whitespace character we have to use the slow variant\n    // otherwise we use the fast variant of finding a word\n    wordDefinition.lastIndex = 0;\n    var match = wordDefinition.exec(text);\n    if (!match) {\n        return null;\n    }\n    // todo@joh the `match` could already be the (first) word\n    var ret = match[0].indexOf(' ') >= 0\n        // did match a word which contains a space character -> use slow word find\n        ? getWordAtPosSlow(column, wordDefinition, text, textOffset)\n        // sane word definition -> use fast word find\n        : getWordAtPosFast(column, wordDefinition, text, textOffset);\n    // both (getWordAtPosFast and getWordAtPosSlow) leave the wordDefinition-RegExp\n    // in an undefined state and to not confuse other users of the wordDefinition\n    // we reset the lastIndex\n    wordDefinition.lastIndex = 0;\n    return ret;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint8 } from './uint.js';\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nvar CharacterClassifier = /** @class */ (function () {\n    function CharacterClassifier(_defaultValue) {\n        var defaultValue = toUint8(_defaultValue);\n        this._defaultValue = defaultValue;\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n        this._map = new Map();\n    }\n    CharacterClassifier._createAsciiMap = function (defaultValue) {\n        var asciiMap = new Uint8Array(256);\n        for (var i = 0; i < 256; i++) {\n            asciiMap[i] = defaultValue;\n        }\n        return asciiMap;\n    };\n    CharacterClassifier.prototype.set = function (charCode, _value) {\n        var value = toUint8(_value);\n        if (charCode >= 0 && charCode < 256) {\n            this._asciiMap[charCode] = value;\n        }\n        else {\n            this._map.set(charCode, value);\n        }\n    };\n    CharacterClassifier.prototype.get = function (charCode) {\n        if (charCode >= 0 && charCode < 256) {\n            return this._asciiMap[charCode];\n        }\n        else {\n            return (this._map.get(charCode) || this._defaultValue);\n        }\n    };\n    return CharacterClassifier;\n}());\nexport { CharacterClassifier };\nvar CharacterSet = /** @class */ (function () {\n    function CharacterSet() {\n        this._actual = new CharacterClassifier(0 /* False */);\n    }\n    CharacterSet.prototype.add = function (charCode) {\n        this._actual.set(charCode, 1 /* True */);\n    };\n    CharacterSet.prototype.has = function (charCode) {\n        return (this._actual.get(charCode) === 1 /* True */);\n    };\n    return CharacterSet;\n}());\nexport { CharacterSet };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nimport { Uint8Matrix } from '../core/uint.js';\nvar StateMachine = /** @class */ (function () {\n    function StateMachine(edges) {\n        var maxCharCode = 0;\n        var maxState = 0 /* Invalid */;\n        for (var i = 0, len = edges.length; i < len; i++) {\n            var _a = edges[i], from = _a[0], chCode = _a[1], to = _a[2];\n            if (chCode > maxCharCode) {\n                maxCharCode = chCode;\n            }\n            if (from > maxState) {\n                maxState = from;\n            }\n            if (to > maxState) {\n                maxState = to;\n            }\n        }\n        maxCharCode++;\n        maxState++;\n        var states = new Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);\n        for (var i = 0, len = edges.length; i < len; i++) {\n            var _b = edges[i], from = _b[0], chCode = _b[1], to = _b[2];\n            states.set(from, chCode, to);\n        }\n        this._states = states;\n        this._maxCharCode = maxCharCode;\n    }\n    StateMachine.prototype.nextState = function (currentState, chCode) {\n        if (chCode < 0 || chCode >= this._maxCharCode) {\n            return 0 /* Invalid */;\n        }\n        return this._states.get(currentState, chCode);\n    };\n    return StateMachine;\n}());\nexport { StateMachine };\n// State machine for http:// or https:// or file://\nvar _stateMachine = null;\nfunction getStateMachine() {\n    if (_stateMachine === null) {\n        _stateMachine = new StateMachine([\n            [1 /* Start */, 104 /* h */, 2 /* H */],\n            [1 /* Start */, 72 /* H */, 2 /* H */],\n            [1 /* Start */, 102 /* f */, 6 /* F */],\n            [1 /* Start */, 70 /* F */, 6 /* F */],\n            [2 /* H */, 116 /* t */, 3 /* HT */],\n            [2 /* H */, 84 /* T */, 3 /* HT */],\n            [3 /* HT */, 116 /* t */, 4 /* HTT */],\n            [3 /* HT */, 84 /* T */, 4 /* HTT */],\n            [4 /* HTT */, 112 /* p */, 5 /* HTTP */],\n            [4 /* HTT */, 80 /* P */, 5 /* HTTP */],\n            [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],\n            [6 /* F */, 105 /* i */, 7 /* FI */],\n            [6 /* F */, 73 /* I */, 7 /* FI */],\n            [7 /* FI */, 108 /* l */, 8 /* FIL */],\n            [7 /* FI */, 76 /* L */, 8 /* FIL */],\n            [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],\n            [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],\n            [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],\n            [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],\n            [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],\n        ]);\n    }\n    return _stateMachine;\n}\nvar _classifier = null;\nfunction getClassifier() {\n    if (_classifier === null) {\n        _classifier = new CharacterClassifier(0 /* None */);\n        var FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…';\n        for (var i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);\n        }\n        var CANNOT_END_WITH_CHARACTERS = '.,;';\n        for (var i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);\n        }\n    }\n    return _classifier;\n}\nvar LinkComputer = /** @class */ (function () {\n    function LinkComputer() {\n    }\n    LinkComputer._createLink = function (classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n        // Do not allow to end link in certain characters...\n        var lastIncludedCharIndex = linkEndIndex - 1;\n        do {\n            var chCode = line.charCodeAt(lastIncludedCharIndex);\n            var chClass = classifier.get(chCode);\n            if (chClass !== 2 /* CannotEndIn */) {\n                break;\n            }\n            lastIncludedCharIndex--;\n        } while (lastIncludedCharIndex > linkBeginIndex);\n        // Handle links enclosed in parens, square brackets and curlys.\n        if (linkBeginIndex > 0) {\n            var charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n            var lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n            if ((charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */)\n                || (charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */)\n                || (charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */)) {\n                // Do not end in ) if ( is before the link start\n                // Do not end in ] if [ is before the link start\n                // Do not end in } if { is before the link start\n                lastIncludedCharIndex--;\n            }\n        }\n        return {\n            range: {\n                startLineNumber: lineNumber,\n                startColumn: linkBeginIndex + 1,\n                endLineNumber: lineNumber,\n                endColumn: lastIncludedCharIndex + 2\n            },\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n        };\n    };\n    LinkComputer.computeLinks = function (model, stateMachine) {\n        if (stateMachine === void 0) { stateMachine = getStateMachine(); }\n        var classifier = getClassifier();\n        var result = [];\n        for (var i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n            var line = model.getLineContent(i);\n            var len = line.length;\n            var j = 0;\n            var linkBeginIndex = 0;\n            var linkBeginChCode = 0;\n            var state = 1 /* Start */;\n            var hasOpenParens = false;\n            var hasOpenSquareBracket = false;\n            var hasOpenCurlyBracket = false;\n            while (j < len) {\n                var resetStateMachine = false;\n                var chCode = line.charCodeAt(j);\n                if (state === 13 /* Accept */) {\n                    var chClass = void 0;\n                    switch (chCode) {\n                        case 40 /* OpenParen */:\n                            hasOpenParens = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 41 /* CloseParen */:\n                            chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 91 /* OpenSquareBracket */:\n                            hasOpenSquareBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 93 /* CloseSquareBracket */:\n                            chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 123 /* OpenCurlyBrace */:\n                            hasOpenCurlyBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 125 /* CloseCurlyBrace */:\n                            chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        /* The following three rules make it that ' or \" or ` are allowed inside links if the link began with a different one */\n                        case 39 /* SingleQuote */:\n                            chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 34 /* DoubleQuote */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 96 /* BackTick */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        default:\n                            chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n                        resetStateMachine = true;\n                    }\n                }\n                else if (state === 12 /* End */) {\n                    var chClass = void 0;\n                    if (chCode === 91 /* OpenSquareBracket */) {\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n                        hasOpenSquareBracket = true;\n                        chClass = 0 /* None */;\n                    }\n                    else {\n                        chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        resetStateMachine = true;\n                    }\n                    else {\n                        state = 13 /* Accept */;\n                    }\n                }\n                else {\n                    state = stateMachine.nextState(state, chCode);\n                    if (state === 0 /* Invalid */) {\n                        resetStateMachine = true;\n                    }\n                }\n                if (resetStateMachine) {\n                    state = 1 /* Start */;\n                    hasOpenParens = false;\n                    hasOpenSquareBracket = false;\n                    hasOpenCurlyBracket = false;\n                    // Record where the link started\n                    linkBeginIndex = j + 1;\n                    linkBeginChCode = chCode;\n                }\n                j++;\n            }\n            if (state === 13 /* Accept */) {\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n            }\n        }\n        return result;\n    };\n    return LinkComputer;\n}());\nexport { LinkComputer };\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nexport function computeLinks(model) {\n    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n        // Unknown caller!\n        return [];\n    }\n    return LinkComputer.computeLinks(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar BasicInplaceReplace = /** @class */ (function () {\n    function BasicInplaceReplace() {\n        this._defaultValueSet = [\n            ['true', 'false'],\n            ['True', 'False'],\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n            ['public', 'protected', 'private'],\n        ];\n    }\n    BasicInplaceReplace.prototype.navigateValueSet = function (range1, text1, range2, text2, up) {\n        if (range1 && text1) {\n            var result = this.doNavigateValueSet(text1, up);\n            if (result) {\n                return {\n                    range: range1,\n                    value: result\n                };\n            }\n        }\n        if (range2 && text2) {\n            var result = this.doNavigateValueSet(text2, up);\n            if (result) {\n                return {\n                    range: range2,\n                    value: result\n                };\n            }\n        }\n        return null;\n    };\n    BasicInplaceReplace.prototype.doNavigateValueSet = function (text, up) {\n        var numberResult = this.numberReplace(text, up);\n        if (numberResult !== null) {\n            return numberResult;\n        }\n        return this.textReplace(text, up);\n    };\n    BasicInplaceReplace.prototype.numberReplace = function (value, up) {\n        var precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n        var n1 = Number(value);\n        var n2 = parseFloat(value);\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n            if (n1 === 0 && !up) {\n                return null; // don't do negative\n                //\t\t\t} else if(n1 === 9 && up) {\n                //\t\t\t\treturn null; // don't insert 10 into a number\n            }\n            else {\n                n1 = Math.floor(n1 * precision);\n                n1 += up ? precision : -precision;\n                return String(n1 / precision);\n            }\n        }\n        return null;\n    };\n    BasicInplaceReplace.prototype.textReplace = function (value, up) {\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\n    };\n    BasicInplaceReplace.prototype.valueSetsReplace = function (valueSets, value, up) {\n        var result = null;\n        for (var i = 0, len = valueSets.length; result === null && i < len; i++) {\n            result = this.valueSetReplace(valueSets[i], value, up);\n        }\n        return result;\n    };\n    BasicInplaceReplace.prototype.valueSetReplace = function (valueSet, value, up) {\n        var idx = valueSet.indexOf(value);\n        if (idx >= 0) {\n            idx += up ? +1 : -1;\n            if (idx < 0) {\n                idx = valueSet.length - 1;\n            }\n            else {\n                idx %= valueSet.length;\n            }\n            return valueSet[idx];\n        }\n        return null;\n    };\n    BasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n    return BasicInplaceReplace;\n}());\nexport { BasicInplaceReplace };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function once(fn) {\n    var _this = this;\n    var didCall = false;\n    var result;\n    return function () {\n        if (didCall) {\n            return result;\n        }\n        didCall = true;\n        result = fn.apply(_this, arguments);\n        return result;\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { FIN } from './iterator.js';\nvar Node = /** @class */ (function () {\n    function Node(element) {\n        this.element = element;\n    }\n    return Node;\n}());\nvar LinkedList = /** @class */ (function () {\n    function LinkedList() {\n        this._size = 0;\n    }\n    Object.defineProperty(LinkedList.prototype, \"size\", {\n        get: function () {\n            return this._size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    LinkedList.prototype.isEmpty = function () {\n        return !this._first;\n    };\n    LinkedList.prototype.unshift = function (element) {\n        return this._insert(element, false);\n    };\n    LinkedList.prototype.push = function (element) {\n        return this._insert(element, true);\n    };\n    LinkedList.prototype._insert = function (element, atTheEnd) {\n        var newNode = new Node(element);\n        if (!this._first) {\n            this._first = newNode;\n            this._last = newNode;\n        }\n        else if (atTheEnd) {\n            // push\n            var oldLast = this._last;\n            this._last = newNode;\n            newNode.prev = oldLast;\n            oldLast.next = newNode;\n        }\n        else {\n            // unshift\n            var oldFirst = this._first;\n            this._first = newNode;\n            newNode.next = oldFirst;\n            oldFirst.prev = newNode;\n        }\n        this._size += 1;\n        return this._remove.bind(this, newNode);\n    };\n    LinkedList.prototype.shift = function () {\n        if (!this._first) {\n            return undefined;\n        }\n        else {\n            var res = this._first.element;\n            this._remove(this._first);\n            return res;\n        }\n    };\n    LinkedList.prototype._remove = function (node) {\n        var candidate = this._first;\n        while (candidate instanceof Node) {\n            if (candidate !== node) {\n                candidate = candidate.next;\n                continue;\n            }\n            if (candidate.prev && candidate.next) {\n                // middle\n                var anchor = candidate.prev;\n                anchor.next = candidate.next;\n                candidate.next.prev = anchor;\n            }\n            else if (!candidate.prev && !candidate.next) {\n                // only node\n                this._first = undefined;\n                this._last = undefined;\n            }\n            else if (!candidate.next) {\n                // last\n                this._last = this._last.prev;\n                this._last.next = undefined;\n            }\n            else if (!candidate.prev) {\n                // first\n                this._first = this._first.next;\n                this._first.prev = undefined;\n            }\n            // done\n            this._size -= 1;\n            break;\n        }\n    };\n    LinkedList.prototype.iterator = function () {\n        var element;\n        var node = this._first;\n        return {\n            next: function () {\n                if (!node) {\n                    return FIN;\n                }\n                if (!element) {\n                    element = { done: false, value: node.element };\n                }\n                else {\n                    element.value = node.element;\n                }\n                node = node.next;\n                return element;\n            }\n        };\n    };\n    return LinkedList;\n}());\nexport { LinkedList };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { onUnexpectedError } from './errors.js';\nimport { once as onceFn } from './functional.js';\nimport { combinedDisposable, Disposable, toDisposable } from './lifecycle.js';\nimport { LinkedList } from './linkedList.js';\nexport var Event;\n(function (Event) {\n    var _disposable = { dispose: function () { } };\n    Event.None = function () { return _disposable; };\n    /**\n     * Given an event, returns another event which only fires once.\n     */\n    function once(event) {\n        return function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            // we need this, in case the event fires during the listener call\n            var didFire = false;\n            var result;\n            result = event(function (e) {\n                if (didFire) {\n                    return;\n                }\n                else if (result) {\n                    result.dispose();\n                }\n                else {\n                    didFire = true;\n                }\n                return listener.call(thisArgs, e);\n            }, null, disposables);\n            if (didFire) {\n                result.dispose();\n            }\n            return result;\n        };\n    }\n    Event.once = once;\n    /**\n     * Given an event and a `map` function, returns another event which maps each element\n     * throught the mapping function.\n     */\n    function map(event, map) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (i) { return listener.call(thisArgs, map(i)); }, null, disposables);\n        });\n    }\n    Event.map = map;\n    /**\n     * Given an event and an `each` function, returns another identical event and calls\n     * the `each` function per each element.\n     */\n    function forEach(event, each) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (i) { each(i); listener.call(thisArgs, i); }, null, disposables);\n        });\n    }\n    Event.forEach = forEach;\n    function filter(event, filter) {\n        return snapshot(function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return event(function (e) { return filter(e) && listener.call(thisArgs, e); }, null, disposables);\n        });\n    }\n    Event.filter = filter;\n    /**\n     * Given an event, returns the same event but typed as `Event<void>`.\n     */\n    function signal(event) {\n        return event;\n    }\n    Event.signal = signal;\n    /**\n     * Given a collection of events, returns a single event which emits\n     * whenever any of the provided events emit.\n     */\n    function any() {\n        var events = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            events[_i] = arguments[_i];\n        }\n        return function (listener, thisArgs, disposables) {\n            if (thisArgs === void 0) { thisArgs = null; }\n            return combinedDisposable(events.map(function (event) { return event(function (e) { return listener.call(thisArgs, e); }, null, disposables); }));\n        };\n    }\n    Event.any = any;\n    /**\n     * Given an event and a `merge` function, returns another event which maps each element\n     * and the cummulative result throught the `merge` function. Similar to `map`, but with memory.\n     */\n    function reduce(event, merge, initial) {\n        var output = initial;\n        return map(event, function (e) {\n            output = merge(output, e);\n            return output;\n        });\n    }\n    Event.reduce = reduce;\n    /**\n     * Given a chain of event processing functions (filter, map, etc), each\n     * function will be invoked per event & per listener. Snapshotting an event\n     * chain allows each function to be invoked just once per event.\n     */\n    function snapshot(event) {\n        var listener;\n        var emitter = new Emitter({\n            onFirstListenerAdd: function () {\n                listener = event(emitter.fire, emitter);\n            },\n            onLastListenerRemove: function () {\n                listener.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.snapshot = snapshot;\n    function debounce(event, merge, delay, leading, leakWarningThreshold) {\n        if (delay === void 0) { delay = 100; }\n        if (leading === void 0) { leading = false; }\n        var subscription;\n        var output = undefined;\n        var handle = undefined;\n        var numDebouncedCalls = 0;\n        var emitter = new Emitter({\n            leakWarningThreshold: leakWarningThreshold,\n            onFirstListenerAdd: function () {\n                subscription = event(function (cur) {\n                    numDebouncedCalls++;\n                    output = merge(output, cur);\n                    if (leading && !handle) {\n                        emitter.fire(output);\n                    }\n                    clearTimeout(handle);\n                    handle = setTimeout(function () {\n                        var _output = output;\n                        output = undefined;\n                        handle = undefined;\n                        if (!leading || numDebouncedCalls > 1) {\n                            emitter.fire(_output);\n                        }\n                        numDebouncedCalls = 0;\n                    }, delay);\n                });\n            },\n            onLastListenerRemove: function () {\n                subscription.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.debounce = debounce;\n    /**\n     * Given an event, it returns another event which fires only once and as soon as\n     * the input event emits. The event data is the number of millis it took for the\n     * event to fire.\n     */\n    function stopwatch(event) {\n        var start = new Date().getTime();\n        return map(once(event), function (_) { return new Date().getTime() - start; });\n    }\n    Event.stopwatch = stopwatch;\n    /**\n     * Given an event, it returns another event which fires only when the event\n     * element changes.\n     */\n    function latch(event) {\n        var firstCall = true;\n        var cache;\n        return filter(event, function (value) {\n            var shouldEmit = firstCall || value !== cache;\n            firstCall = false;\n            cache = value;\n            return shouldEmit;\n        });\n    }\n    Event.latch = latch;\n    /**\n     * Buffers the provided event until a first listener comes\n     * along, at which point fire all the events at once and\n     * pipe the event from then on.\n     *\n     * ```typescript\n     * const emitter = new Emitter<number>();\n     * const event = emitter.event;\n     * const bufferedEvent = buffer(event);\n     *\n     * emitter.fire(1);\n     * emitter.fire(2);\n     * emitter.fire(3);\n     * // nothing...\n     *\n     * const listener = bufferedEvent(num => console.log(num));\n     * // 1, 2, 3\n     *\n     * emitter.fire(4);\n     * // 4\n     * ```\n     */\n    function buffer(event, nextTick, _buffer) {\n        if (nextTick === void 0) { nextTick = false; }\n        if (_buffer === void 0) { _buffer = []; }\n        var buffer = _buffer.slice();\n        var listener = event(function (e) {\n            if (buffer) {\n                buffer.push(e);\n            }\n            else {\n                emitter.fire(e);\n            }\n        });\n        var flush = function () {\n            if (buffer) {\n                buffer.forEach(function (e) { return emitter.fire(e); });\n            }\n            buffer = null;\n        };\n        var emitter = new Emitter({\n            onFirstListenerAdd: function () {\n                if (!listener) {\n                    listener = event(function (e) { return emitter.fire(e); });\n                }\n            },\n            onFirstListenerDidAdd: function () {\n                if (buffer) {\n                    if (nextTick) {\n                        setTimeout(flush);\n                    }\n                    else {\n                        flush();\n                    }\n                }\n            },\n            onLastListenerRemove: function () {\n                if (listener) {\n                    listener.dispose();\n                }\n                listener = null;\n            }\n        });\n        return emitter.event;\n    }\n    Event.buffer = buffer;\n    /**\n     * Similar to `buffer` but it buffers indefinitely and repeats\n     * the buffered events to every new listener.\n     */\n    function echo(event, nextTick, buffer) {\n        if (nextTick === void 0) { nextTick = false; }\n        if (buffer === void 0) { buffer = []; }\n        buffer = buffer.slice();\n        event(function (e) {\n            buffer.push(e);\n            emitter.fire(e);\n        });\n        var flush = function (listener, thisArgs) { return buffer.forEach(function (e) { return listener.call(thisArgs, e); }); };\n        var emitter = new Emitter({\n            onListenerDidAdd: function (emitter, listener, thisArgs) {\n                if (nextTick) {\n                    setTimeout(function () { return flush(listener, thisArgs); });\n                }\n                else {\n                    flush(listener, thisArgs);\n                }\n            }\n        });\n        return emitter.event;\n    }\n    Event.echo = echo;\n    var ChainableEvent = /** @class */ (function () {\n        function ChainableEvent(event) {\n            this.event = event;\n        }\n        ChainableEvent.prototype.map = function (fn) {\n            return new ChainableEvent(map(this.event, fn));\n        };\n        ChainableEvent.prototype.forEach = function (fn) {\n            return new ChainableEvent(forEach(this.event, fn));\n        };\n        ChainableEvent.prototype.filter = function (fn) {\n            return new ChainableEvent(filter(this.event, fn));\n        };\n        ChainableEvent.prototype.reduce = function (merge, initial) {\n            return new ChainableEvent(reduce(this.event, merge, initial));\n        };\n        ChainableEvent.prototype.latch = function () {\n            return new ChainableEvent(latch(this.event));\n        };\n        ChainableEvent.prototype.on = function (listener, thisArgs, disposables) {\n            return this.event(listener, thisArgs, disposables);\n        };\n        ChainableEvent.prototype.once = function (listener, thisArgs, disposables) {\n            return once(this.event)(listener, thisArgs, disposables);\n        };\n        return ChainableEvent;\n    }());\n    function chain(event) {\n        return new ChainableEvent(event);\n    }\n    Event.chain = chain;\n    function fromNodeEventEmitter(emitter, eventName, map) {\n        if (map === void 0) { map = function (id) { return id; }; }\n        var fn = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return result.fire(map.apply(void 0, args));\n        };\n        var onFirstListenerAdd = function () { return emitter.on(eventName, fn); };\n        var onLastListenerRemove = function () { return emitter.removeListener(eventName, fn); };\n        var result = new Emitter({ onFirstListenerAdd: onFirstListenerAdd, onLastListenerRemove: onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromNodeEventEmitter = fromNodeEventEmitter;\n    function fromPromise(promise) {\n        var emitter = new Emitter();\n        var shouldEmit = false;\n        promise\n            .then(undefined, function () { return null; })\n            .then(function () {\n            if (!shouldEmit) {\n                setTimeout(function () { return emitter.fire(undefined); }, 0);\n            }\n            else {\n                emitter.fire(undefined);\n            }\n        });\n        shouldEmit = true;\n        return emitter.event;\n    }\n    Event.fromPromise = fromPromise;\n    function toPromise(event) {\n        return new Promise(function (c) { return once(event)(c); });\n    }\n    Event.toPromise = toPromise;\n})(Event || (Event = {}));\nvar _globalLeakWarningThreshold = -1;\nvar LeakageMonitor = /** @class */ (function () {\n    function LeakageMonitor(customThreshold, name) {\n        if (name === void 0) { name = Math.random().toString(18).slice(2, 5); }\n        this.customThreshold = customThreshold;\n        this.name = name;\n        this._warnCountdown = 0;\n    }\n    LeakageMonitor.prototype.dispose = function () {\n        if (this._stacks) {\n            this._stacks.clear();\n        }\n    };\n    LeakageMonitor.prototype.check = function (listenerCount) {\n        var _this = this;\n        var threshold = _globalLeakWarningThreshold;\n        if (typeof this.customThreshold === 'number') {\n            threshold = this.customThreshold;\n        }\n        if (threshold <= 0 || listenerCount < threshold) {\n            return undefined;\n        }\n        if (!this._stacks) {\n            this._stacks = new Map();\n        }\n        var stack = new Error().stack.split('\\n').slice(3).join('\\n');\n        var count = (this._stacks.get(stack) || 0);\n        this._stacks.set(stack, count + 1);\n        this._warnCountdown -= 1;\n        if (this._warnCountdown <= 0) {\n            // only warn on first exceed and then every time the limit\n            // is exceeded by 50% again\n            this._warnCountdown = threshold * 0.5;\n            // find most frequent listener and print warning\n            var topStack_1;\n            var topCount_1 = 0;\n            this._stacks.forEach(function (count, stack) {\n                if (!topStack_1 || topCount_1 < count) {\n                    topStack_1 = stack;\n                    topCount_1 = count;\n                }\n            });\n            console.warn(\"[\" + this.name + \"] potential listener LEAK detected, having \" + listenerCount + \" listeners already. MOST frequent listener (\" + topCount_1 + \"):\");\n            console.warn(topStack_1);\n        }\n        return function () {\n            var count = (_this._stacks.get(stack) || 0);\n            _this._stacks.set(stack, count - 1);\n        };\n    };\n    return LeakageMonitor;\n}());\n/**\n * The Emitter can be used to expose an Event to the public\n * to fire it from the insides.\n * Sample:\n    class Document {\n\n        private _onDidChange = new Emitter<(value:string)=>any>();\n\n        public onDidChange = this._onDidChange.event;\n\n        // getter-style\n        // get onDidChange(): Event<(value:string)=>any> {\n        // \treturn this._onDidChange.event;\n        // }\n\n        private _doIt() {\n            //...\n            this._onDidChange.fire(value);\n        }\n    }\n */\nvar Emitter = /** @class */ (function () {\n    function Emitter(options) {\n        this._disposed = false;\n        this._options = options;\n        this._leakageMon = _globalLeakWarningThreshold > 0\n            ? new LeakageMonitor(this._options && this._options.leakWarningThreshold)\n            : undefined;\n    }\n    Object.defineProperty(Emitter.prototype, \"event\", {\n        /**\n         * For the public to allow to subscribe\n         * to events from this Emitter\n         */\n        get: function () {\n            var _this = this;\n            if (!this._event) {\n                this._event = function (listener, thisArgs, disposables) {\n                    if (!_this._listeners) {\n                        _this._listeners = new LinkedList();\n                    }\n                    var firstListener = _this._listeners.isEmpty();\n                    if (firstListener && _this._options && _this._options.onFirstListenerAdd) {\n                        _this._options.onFirstListenerAdd(_this);\n                    }\n                    var remove = _this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\n                    if (firstListener && _this._options && _this._options.onFirstListenerDidAdd) {\n                        _this._options.onFirstListenerDidAdd(_this);\n                    }\n                    if (_this._options && _this._options.onListenerDidAdd) {\n                        _this._options.onListenerDidAdd(_this, listener, thisArgs);\n                    }\n                    // check and record this emitter for potential leakage\n                    var removeMonitor;\n                    if (_this._leakageMon) {\n                        removeMonitor = _this._leakageMon.check(_this._listeners.size);\n                    }\n                    var result;\n                    result = {\n                        dispose: function () {\n                            if (removeMonitor) {\n                                removeMonitor();\n                            }\n                            result.dispose = Emitter._noop;\n                            if (!_this._disposed) {\n                                remove();\n                                if (_this._options && _this._options.onLastListenerRemove) {\n                                    var hasListeners = (_this._listeners && !_this._listeners.isEmpty());\n                                    if (!hasListeners) {\n                                        _this._options.onLastListenerRemove(_this);\n                                    }\n                                }\n                            }\n                        }\n                    };\n                    if (Array.isArray(disposables)) {\n                        disposables.push(result);\n                    }\n                    return result;\n                };\n            }\n            return this._event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * To be kept private to fire an event to\n     * subscribers\n     */\n    Emitter.prototype.fire = function (event) {\n        if (this._listeners) {\n            // put all [listener,event]-pairs into delivery queue\n            // then emit all event. an inner/nested event might be\n            // the driver of this\n            if (!this._deliveryQueue) {\n                this._deliveryQueue = [];\n            }\n            for (var iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {\n                this._deliveryQueue.push([e.value, event]);\n            }\n            while (this._deliveryQueue.length > 0) {\n                var _a = this._deliveryQueue.shift(), listener = _a[0], event_1 = _a[1];\n                try {\n                    if (typeof listener === 'function') {\n                        listener.call(undefined, event_1);\n                    }\n                    else {\n                        listener[0].call(listener[1], event_1);\n                    }\n                }\n                catch (e) {\n                    onUnexpectedError(e);\n                }\n            }\n        }\n    };\n    Emitter.prototype.dispose = function () {\n        if (this._listeners) {\n            this._listeners = undefined;\n        }\n        if (this._deliveryQueue) {\n            this._deliveryQueue.length = 0;\n        }\n        if (this._leakageMon) {\n            this._leakageMon.dispose();\n        }\n        this._disposed = true;\n    };\n    Emitter._noop = function () { };\n    return Emitter;\n}());\nexport { Emitter };\nvar EventMultiplexer = /** @class */ (function () {\n    function EventMultiplexer() {\n        var _this = this;\n        this.hasListeners = false;\n        this.events = [];\n        this.emitter = new Emitter({\n            onFirstListenerAdd: function () { return _this.onFirstListenerAdd(); },\n            onLastListenerRemove: function () { return _this.onLastListenerRemove(); }\n        });\n    }\n    Object.defineProperty(EventMultiplexer.prototype, \"event\", {\n        get: function () {\n            return this.emitter.event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    EventMultiplexer.prototype.add = function (event) {\n        var _this = this;\n        var e = { event: event, listener: null };\n        this.events.push(e);\n        if (this.hasListeners) {\n            this.hook(e);\n        }\n        var dispose = function () {\n            if (_this.hasListeners) {\n                _this.unhook(e);\n            }\n            var idx = _this.events.indexOf(e);\n            _this.events.splice(idx, 1);\n        };\n        return toDisposable(onceFn(dispose));\n    };\n    EventMultiplexer.prototype.onFirstListenerAdd = function () {\n        var _this = this;\n        this.hasListeners = true;\n        this.events.forEach(function (e) { return _this.hook(e); });\n    };\n    EventMultiplexer.prototype.onLastListenerRemove = function () {\n        var _this = this;\n        this.hasListeners = false;\n        this.events.forEach(function (e) { return _this.unhook(e); });\n    };\n    EventMultiplexer.prototype.hook = function (e) {\n        var _this = this;\n        e.listener = e.event(function (r) { return _this.emitter.fire(r); });\n    };\n    EventMultiplexer.prototype.unhook = function (e) {\n        if (e.listener) {\n            e.listener.dispose();\n        }\n        e.listener = null;\n    };\n    EventMultiplexer.prototype.dispose = function () {\n        this.emitter.dispose();\n    };\n    return EventMultiplexer;\n}());\nexport { EventMultiplexer };\n/**\n * The EventBufferer is useful in situations in which you want\n * to delay firing your events during some code.\n * You can wrap that code and be sure that the event will not\n * be fired during that wrap.\n *\n * ```\n * const emitter: Emitter;\n * const delayer = new EventDelayer();\n * const delayedEvent = delayer.wrapEvent(emitter.event);\n *\n * delayedEvent(console.log);\n *\n * delayer.bufferEvents(() => {\n *   emitter.fire(); // event will not be fired yet\n * });\n *\n * // event will only be fired at this point\n * ```\n */\nvar EventBufferer = /** @class */ (function () {\n    function EventBufferer() {\n        this.buffers = [];\n    }\n    EventBufferer.prototype.wrapEvent = function (event) {\n        var _this = this;\n        return function (listener, thisArgs, disposables) {\n            return event(function (i) {\n                var buffer = _this.buffers[_this.buffers.length - 1];\n                if (buffer) {\n                    buffer.push(function () { return listener.call(thisArgs, i); });\n                }\n                else {\n                    listener.call(thisArgs, i);\n                }\n            }, undefined, disposables);\n        };\n    };\n    EventBufferer.prototype.bufferEvents = function (fn) {\n        var buffer = [];\n        this.buffers.push(buffer);\n        var r = fn();\n        this.buffers.pop();\n        buffer.forEach(function (flush) { return flush(); });\n        return r;\n    };\n    return EventBufferer;\n}());\nexport { EventBufferer };\n/**\n * A Relay is an event forwarder which functions as a replugabble event pipe.\n * Once created, you can connect an input event to it and it will simply forward\n * events from that input event through its own `event` property. The `input`\n * can be changed at any point in time.\n */\nvar Relay = /** @class */ (function () {\n    function Relay() {\n        var _this = this;\n        this.listening = false;\n        this.inputEvent = Event.None;\n        this.inputEventListener = Disposable.None;\n        this.emitter = new Emitter({\n            onFirstListenerDidAdd: function () {\n                _this.listening = true;\n                _this.inputEventListener = _this.inputEvent(_this.emitter.fire, _this.emitter);\n            },\n            onLastListenerRemove: function () {\n                _this.listening = false;\n                _this.inputEventListener.dispose();\n            }\n        });\n        this.event = this.emitter.event;\n    }\n    Object.defineProperty(Relay.prototype, \"input\", {\n        set: function (event) {\n            this.inputEvent = event;\n            if (this.listening) {\n                this.inputEventListener.dispose();\n                this.inputEventListener = event(this.emitter.fire, this.emitter);\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Relay.prototype.dispose = function () {\n        this.inputEventListener.dispose();\n        this.emitter.dispose();\n    };\n    return Relay;\n}());\nexport { Relay };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter, Event } from './event.js';\nvar shortcutEvent = Object.freeze(function (callback, context) {\n    var handle = setTimeout(callback.bind(context), 0);\n    return { dispose: function () { clearTimeout(handle); } };\n});\nexport var CancellationToken;\n(function (CancellationToken) {\n    function isCancellationToken(thing) {\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n            return true;\n        }\n        if (thing instanceof MutableToken) {\n            return true;\n        }\n        if (!thing || typeof thing !== 'object') {\n            return false;\n        }\n        return typeof thing.isCancellationRequested === 'boolean'\n            && typeof thing.onCancellationRequested === 'function';\n    }\n    CancellationToken.isCancellationToken = isCancellationToken;\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: Event.None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: shortcutEvent\n    });\n})(CancellationToken || (CancellationToken = {}));\nvar MutableToken = /** @class */ (function () {\n    function MutableToken() {\n        this._isCancelled = false;\n        this._emitter = null;\n    }\n    MutableToken.prototype.cancel = function () {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    };\n    Object.defineProperty(MutableToken.prototype, \"isCancellationRequested\", {\n        get: function () {\n            return this._isCancelled;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MutableToken.prototype, \"onCancellationRequested\", {\n        get: function () {\n            if (this._isCancelled) {\n                return shortcutEvent;\n            }\n            if (!this._emitter) {\n                this._emitter = new Emitter();\n            }\n            return this._emitter.event;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MutableToken.prototype.dispose = function () {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = null;\n        }\n    };\n    return MutableToken;\n}());\nvar CancellationTokenSource = /** @class */ (function () {\n    function CancellationTokenSource() {\n    }\n    Object.defineProperty(CancellationTokenSource.prototype, \"token\", {\n        get: function () {\n            if (!this._token) {\n                // be lazy and create the token only when\n                // actually needed\n                this._token = new MutableToken();\n            }\n            return this._token;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CancellationTokenSource.prototype.cancel = function () {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually cancel\n            this._token.cancel();\n        }\n    };\n    CancellationTokenSource.prototype.dispose = function () {\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    };\n    return CancellationTokenSource;\n}());\nexport { CancellationTokenSource };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { illegalArgument } from './errors.js';\nvar KeyCodeStrMap = /** @class */ (function () {\n    function KeyCodeStrMap() {\n        this._keyCodeToStr = [];\n        this._strToKeyCode = Object.create(null);\n    }\n    KeyCodeStrMap.prototype.define = function (keyCode, str) {\n        this._keyCodeToStr[keyCode] = str;\n        this._strToKeyCode[str.toLowerCase()] = keyCode;\n    };\n    KeyCodeStrMap.prototype.keyCodeToStr = function (keyCode) {\n        return this._keyCodeToStr[keyCode];\n    };\n    KeyCodeStrMap.prototype.strToKeyCode = function (str) {\n        return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;\n    };\n    return KeyCodeStrMap;\n}());\nvar uiMap = new KeyCodeStrMap();\nvar userSettingsUSMap = new KeyCodeStrMap();\nvar userSettingsGeneralMap = new KeyCodeStrMap();\n(function () {\n    function define(keyCode, uiLabel, usUserSettingsLabel, generalUserSettingsLabel) {\n        if (usUserSettingsLabel === void 0) { usUserSettingsLabel = uiLabel; }\n        if (generalUserSettingsLabel === void 0) { generalUserSettingsLabel = usUserSettingsLabel; }\n        uiMap.define(keyCode, uiLabel);\n        userSettingsUSMap.define(keyCode, usUserSettingsLabel);\n        userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel);\n    }\n    define(0 /* Unknown */, 'unknown');\n    define(1 /* Backspace */, 'Backspace');\n    define(2 /* Tab */, 'Tab');\n    define(3 /* Enter */, 'Enter');\n    define(4 /* Shift */, 'Shift');\n    define(5 /* Ctrl */, 'Ctrl');\n    define(6 /* Alt */, 'Alt');\n    define(7 /* PauseBreak */, 'PauseBreak');\n    define(8 /* CapsLock */, 'CapsLock');\n    define(9 /* Escape */, 'Escape');\n    define(10 /* Space */, 'Space');\n    define(11 /* PageUp */, 'PageUp');\n    define(12 /* PageDown */, 'PageDown');\n    define(13 /* End */, 'End');\n    define(14 /* Home */, 'Home');\n    define(15 /* LeftArrow */, 'LeftArrow', 'Left');\n    define(16 /* UpArrow */, 'UpArrow', 'Up');\n    define(17 /* RightArrow */, 'RightArrow', 'Right');\n    define(18 /* DownArrow */, 'DownArrow', 'Down');\n    define(19 /* Insert */, 'Insert');\n    define(20 /* Delete */, 'Delete');\n    define(21 /* KEY_0 */, '0');\n    define(22 /* KEY_1 */, '1');\n    define(23 /* KEY_2 */, '2');\n    define(24 /* KEY_3 */, '3');\n    define(25 /* KEY_4 */, '4');\n    define(26 /* KEY_5 */, '5');\n    define(27 /* KEY_6 */, '6');\n    define(28 /* KEY_7 */, '7');\n    define(29 /* KEY_8 */, '8');\n    define(30 /* KEY_9 */, '9');\n    define(31 /* KEY_A */, 'A');\n    define(32 /* KEY_B */, 'B');\n    define(33 /* KEY_C */, 'C');\n    define(34 /* KEY_D */, 'D');\n    define(35 /* KEY_E */, 'E');\n    define(36 /* KEY_F */, 'F');\n    define(37 /* KEY_G */, 'G');\n    define(38 /* KEY_H */, 'H');\n    define(39 /* KEY_I */, 'I');\n    define(40 /* KEY_J */, 'J');\n    define(41 /* KEY_K */, 'K');\n    define(42 /* KEY_L */, 'L');\n    define(43 /* KEY_M */, 'M');\n    define(44 /* KEY_N */, 'N');\n    define(45 /* KEY_O */, 'O');\n    define(46 /* KEY_P */, 'P');\n    define(47 /* KEY_Q */, 'Q');\n    define(48 /* KEY_R */, 'R');\n    define(49 /* KEY_S */, 'S');\n    define(50 /* KEY_T */, 'T');\n    define(51 /* KEY_U */, 'U');\n    define(52 /* KEY_V */, 'V');\n    define(53 /* KEY_W */, 'W');\n    define(54 /* KEY_X */, 'X');\n    define(55 /* KEY_Y */, 'Y');\n    define(56 /* KEY_Z */, 'Z');\n    define(57 /* Meta */, 'Meta');\n    define(58 /* ContextMenu */, 'ContextMenu');\n    define(59 /* F1 */, 'F1');\n    define(60 /* F2 */, 'F2');\n    define(61 /* F3 */, 'F3');\n    define(62 /* F4 */, 'F4');\n    define(63 /* F5 */, 'F5');\n    define(64 /* F6 */, 'F6');\n    define(65 /* F7 */, 'F7');\n    define(66 /* F8 */, 'F8');\n    define(67 /* F9 */, 'F9');\n    define(68 /* F10 */, 'F10');\n    define(69 /* F11 */, 'F11');\n    define(70 /* F12 */, 'F12');\n    define(71 /* F13 */, 'F13');\n    define(72 /* F14 */, 'F14');\n    define(73 /* F15 */, 'F15');\n    define(74 /* F16 */, 'F16');\n    define(75 /* F17 */, 'F17');\n    define(76 /* F18 */, 'F18');\n    define(77 /* F19 */, 'F19');\n    define(78 /* NumLock */, 'NumLock');\n    define(79 /* ScrollLock */, 'ScrollLock');\n    define(80 /* US_SEMICOLON */, ';', ';', 'OEM_1');\n    define(81 /* US_EQUAL */, '=', '=', 'OEM_PLUS');\n    define(82 /* US_COMMA */, ',', ',', 'OEM_COMMA');\n    define(83 /* US_MINUS */, '-', '-', 'OEM_MINUS');\n    define(84 /* US_DOT */, '.', '.', 'OEM_PERIOD');\n    define(85 /* US_SLASH */, '/', '/', 'OEM_2');\n    define(86 /* US_BACKTICK */, '`', '`', 'OEM_3');\n    define(110 /* ABNT_C1 */, 'ABNT_C1');\n    define(111 /* ABNT_C2 */, 'ABNT_C2');\n    define(87 /* US_OPEN_SQUARE_BRACKET */, '[', '[', 'OEM_4');\n    define(88 /* US_BACKSLASH */, '\\\\', '\\\\', 'OEM_5');\n    define(89 /* US_CLOSE_SQUARE_BRACKET */, ']', ']', 'OEM_6');\n    define(90 /* US_QUOTE */, '\\'', '\\'', 'OEM_7');\n    define(91 /* OEM_8 */, 'OEM_8');\n    define(92 /* OEM_102 */, 'OEM_102');\n    define(93 /* NUMPAD_0 */, 'NumPad0');\n    define(94 /* NUMPAD_1 */, 'NumPad1');\n    define(95 /* NUMPAD_2 */, 'NumPad2');\n    define(96 /* NUMPAD_3 */, 'NumPad3');\n    define(97 /* NUMPAD_4 */, 'NumPad4');\n    define(98 /* NUMPAD_5 */, 'NumPad5');\n    define(99 /* NUMPAD_6 */, 'NumPad6');\n    define(100 /* NUMPAD_7 */, 'NumPad7');\n    define(101 /* NUMPAD_8 */, 'NumPad8');\n    define(102 /* NUMPAD_9 */, 'NumPad9');\n    define(103 /* NUMPAD_MULTIPLY */, 'NumPad_Multiply');\n    define(104 /* NUMPAD_ADD */, 'NumPad_Add');\n    define(105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator');\n    define(106 /* NUMPAD_SUBTRACT */, 'NumPad_Subtract');\n    define(107 /* NUMPAD_DECIMAL */, 'NumPad_Decimal');\n    define(108 /* NUMPAD_DIVIDE */, 'NumPad_Divide');\n})();\nexport var KeyCodeUtils;\n(function (KeyCodeUtils) {\n    function toString(keyCode) {\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toString = toString;\n    function fromString(key) {\n        return uiMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromString = fromString;\n    function toUserSettingsUS(keyCode) {\n        return userSettingsUSMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\n    function toUserSettingsGeneral(keyCode) {\n        return userSettingsGeneralMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\n    function fromUserSettings(key) {\n        return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromUserSettings = fromUserSettings;\n})(KeyCodeUtils || (KeyCodeUtils = {}));\nexport function KeyChord(firstPart, secondPart) {\n    var chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\n    return (firstPart | chordPart) >>> 0;\n}\nexport function createKeybinding(keybinding, OS) {\n    if (keybinding === 0) {\n        return null;\n    }\n    var firstPart = (keybinding & 0x0000FFFF) >>> 0;\n    var chordPart = (keybinding & 0xFFFF0000) >>> 16;\n    if (chordPart !== 0) {\n        return new ChordKeybinding([\n            createSimpleKeybinding(firstPart, OS),\n            createSimpleKeybinding(chordPart, OS)\n        ]);\n    }\n    return new ChordKeybinding([createSimpleKeybinding(firstPart, OS)]);\n}\nexport function createSimpleKeybinding(keybinding, OS) {\n    var ctrlCmd = (keybinding & 2048 /* CtrlCmd */ ? true : false);\n    var winCtrl = (keybinding & 256 /* WinCtrl */ ? true : false);\n    var ctrlKey = (OS === 2 /* Macintosh */ ? winCtrl : ctrlCmd);\n    var shiftKey = (keybinding & 1024 /* Shift */ ? true : false);\n    var altKey = (keybinding & 512 /* Alt */ ? true : false);\n    var metaKey = (OS === 2 /* Macintosh */ ? ctrlCmd : winCtrl);\n    var keyCode = (keybinding & 255 /* KeyCode */);\n    return new SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode);\n}\nvar SimpleKeybinding = /** @class */ (function () {\n    function SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode) {\n        this.ctrlKey = ctrlKey;\n        this.shiftKey = shiftKey;\n        this.altKey = altKey;\n        this.metaKey = metaKey;\n        this.keyCode = keyCode;\n    }\n    SimpleKeybinding.prototype.equals = function (other) {\n        return (this.ctrlKey === other.ctrlKey\n            && this.shiftKey === other.shiftKey\n            && this.altKey === other.altKey\n            && this.metaKey === other.metaKey\n            && this.keyCode === other.keyCode);\n    };\n    SimpleKeybinding.prototype.isModifierKey = function () {\n        return (this.keyCode === 0 /* Unknown */\n            || this.keyCode === 5 /* Ctrl */\n            || this.keyCode === 57 /* Meta */\n            || this.keyCode === 6 /* Alt */\n            || this.keyCode === 4 /* Shift */);\n    };\n    SimpleKeybinding.prototype.toChord = function () {\n        return new ChordKeybinding([this]);\n    };\n    /**\n     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?\n     */\n    SimpleKeybinding.prototype.isDuplicateModifierCase = function () {\n        return ((this.ctrlKey && this.keyCode === 5 /* Ctrl */)\n            || (this.shiftKey && this.keyCode === 4 /* Shift */)\n            || (this.altKey && this.keyCode === 6 /* Alt */)\n            || (this.metaKey && this.keyCode === 57 /* Meta */));\n    };\n    return SimpleKeybinding;\n}());\nexport { SimpleKeybinding };\nvar ChordKeybinding = /** @class */ (function () {\n    function ChordKeybinding(parts) {\n        if (parts.length === 0) {\n            throw illegalArgument(\"parts\");\n        }\n        this.parts = parts;\n    }\n    ChordKeybinding.prototype.equals = function (other) {\n        if (other === null) {\n            return false;\n        }\n        if (this.parts.length !== other.parts.length) {\n            return false;\n        }\n        for (var i = 0; i < this.parts.length; i++) {\n            if (!this.parts[i].equals(other.parts[i])) {\n                return false;\n            }\n        }\n        return true;\n    };\n    return ChordKeybinding;\n}());\nexport { ChordKeybinding };\nvar ResolvedKeybindingPart = /** @class */ (function () {\n    function ResolvedKeybindingPart(ctrlKey, shiftKey, altKey, metaKey, kbLabel, kbAriaLabel) {\n        this.ctrlKey = ctrlKey;\n        this.shiftKey = shiftKey;\n        this.altKey = altKey;\n        this.metaKey = metaKey;\n        this.keyLabel = kbLabel;\n        this.keyAriaLabel = kbAriaLabel;\n    }\n    return ResolvedKeybindingPart;\n}());\nexport { ResolvedKeybindingPart };\n/**\n * A resolved keybinding. Can be a simple keybinding or a chord keybinding.\n */\nvar ResolvedKeybinding = /** @class */ (function () {\n    function ResolvedKeybinding() {\n    }\n    return ResolvedKeybinding;\n}());\nexport { ResolvedKeybinding };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\nexport var MarkerTag;\n(function (MarkerTag) {\n    MarkerTag[MarkerTag[\"Unnecessary\"] = 1] = \"Unnecessary\";\n})(MarkerTag || (MarkerTag = {}));\nexport var MarkerSeverity;\n(function (MarkerSeverity) {\n    MarkerSeverity[MarkerSeverity[\"Hint\"] = 1] = \"Hint\";\n    MarkerSeverity[MarkerSeverity[\"Info\"] = 2] = \"Info\";\n    MarkerSeverity[MarkerSeverity[\"Warning\"] = 4] = \"Warning\";\n    MarkerSeverity[MarkerSeverity[\"Error\"] = 8] = \"Error\";\n})(MarkerSeverity || (MarkerSeverity = {}));\n/**\n * Virtual Key Codes, the value does not hold any inherent meaning.\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n * But these are \"more general\", as they should work across browsers & OS`s.\n */\nexport var KeyCode;\n(function (KeyCode) {\n    /**\n     * Placed first to cover the 0 value of the enum.\n     */\n    KeyCode[KeyCode[\"Unknown\"] = 0] = \"Unknown\";\n    KeyCode[KeyCode[\"Backspace\"] = 1] = \"Backspace\";\n    KeyCode[KeyCode[\"Tab\"] = 2] = \"Tab\";\n    KeyCode[KeyCode[\"Enter\"] = 3] = \"Enter\";\n    KeyCode[KeyCode[\"Shift\"] = 4] = \"Shift\";\n    KeyCode[KeyCode[\"Ctrl\"] = 5] = \"Ctrl\";\n    KeyCode[KeyCode[\"Alt\"] = 6] = \"Alt\";\n    KeyCode[KeyCode[\"PauseBreak\"] = 7] = \"PauseBreak\";\n    KeyCode[KeyCode[\"CapsLock\"] = 8] = \"CapsLock\";\n    KeyCode[KeyCode[\"Escape\"] = 9] = \"Escape\";\n    KeyCode[KeyCode[\"Space\"] = 10] = \"Space\";\n    KeyCode[KeyCode[\"PageUp\"] = 11] = \"PageUp\";\n    KeyCode[KeyCode[\"PageDown\"] = 12] = \"PageDown\";\n    KeyCode[KeyCode[\"End\"] = 13] = \"End\";\n    KeyCode[KeyCode[\"Home\"] = 14] = \"Home\";\n    KeyCode[KeyCode[\"LeftArrow\"] = 15] = \"LeftArrow\";\n    KeyCode[KeyCode[\"UpArrow\"] = 16] = \"UpArrow\";\n    KeyCode[KeyCode[\"RightArrow\"] = 17] = \"RightArrow\";\n    KeyCode[KeyCode[\"DownArrow\"] = 18] = \"DownArrow\";\n    KeyCode[KeyCode[\"Insert\"] = 19] = \"Insert\";\n    KeyCode[KeyCode[\"Delete\"] = 20] = \"Delete\";\n    KeyCode[KeyCode[\"KEY_0\"] = 21] = \"KEY_0\";\n    KeyCode[KeyCode[\"KEY_1\"] = 22] = \"KEY_1\";\n    KeyCode[KeyCode[\"KEY_2\"] = 23] = \"KEY_2\";\n    KeyCode[KeyCode[\"KEY_3\"] = 24] = \"KEY_3\";\n    KeyCode[KeyCode[\"KEY_4\"] = 25] = \"KEY_4\";\n    KeyCode[KeyCode[\"KEY_5\"] = 26] = \"KEY_5\";\n    KeyCode[KeyCode[\"KEY_6\"] = 27] = \"KEY_6\";\n    KeyCode[KeyCode[\"KEY_7\"] = 28] = \"KEY_7\";\n    KeyCode[KeyCode[\"KEY_8\"] = 29] = \"KEY_8\";\n    KeyCode[KeyCode[\"KEY_9\"] = 30] = \"KEY_9\";\n    KeyCode[KeyCode[\"KEY_A\"] = 31] = \"KEY_A\";\n    KeyCode[KeyCode[\"KEY_B\"] = 32] = \"KEY_B\";\n    KeyCode[KeyCode[\"KEY_C\"] = 33] = \"KEY_C\";\n    KeyCode[KeyCode[\"KEY_D\"] = 34] = \"KEY_D\";\n    KeyCode[KeyCode[\"KEY_E\"] = 35] = \"KEY_E\";\n    KeyCode[KeyCode[\"KEY_F\"] = 36] = \"KEY_F\";\n    KeyCode[KeyCode[\"KEY_G\"] = 37] = \"KEY_G\";\n    KeyCode[KeyCode[\"KEY_H\"] = 38] = \"KEY_H\";\n    KeyCode[KeyCode[\"KEY_I\"] = 39] = \"KEY_I\";\n    KeyCode[KeyCode[\"KEY_J\"] = 40] = \"KEY_J\";\n    KeyCode[KeyCode[\"KEY_K\"] = 41] = \"KEY_K\";\n    KeyCode[KeyCode[\"KEY_L\"] = 42] = \"KEY_L\";\n    KeyCode[KeyCode[\"KEY_M\"] = 43] = \"KEY_M\";\n    KeyCode[KeyCode[\"KEY_N\"] = 44] = \"KEY_N\";\n    KeyCode[KeyCode[\"KEY_O\"] = 45] = \"KEY_O\";\n    KeyCode[KeyCode[\"KEY_P\"] = 46] = \"KEY_P\";\n    KeyCode[KeyCode[\"KEY_Q\"] = 47] = \"KEY_Q\";\n    KeyCode[KeyCode[\"KEY_R\"] = 48] = \"KEY_R\";\n    KeyCode[KeyCode[\"KEY_S\"] = 49] = \"KEY_S\";\n    KeyCode[KeyCode[\"KEY_T\"] = 50] = \"KEY_T\";\n    KeyCode[KeyCode[\"KEY_U\"] = 51] = \"KEY_U\";\n    KeyCode[KeyCode[\"KEY_V\"] = 52] = \"KEY_V\";\n    KeyCode[KeyCode[\"KEY_W\"] = 53] = \"KEY_W\";\n    KeyCode[KeyCode[\"KEY_X\"] = 54] = \"KEY_X\";\n    KeyCode[KeyCode[\"KEY_Y\"] = 55] = \"KEY_Y\";\n    KeyCode[KeyCode[\"KEY_Z\"] = 56] = \"KEY_Z\";\n    KeyCode[KeyCode[\"Meta\"] = 57] = \"Meta\";\n    KeyCode[KeyCode[\"ContextMenu\"] = 58] = \"ContextMenu\";\n    KeyCode[KeyCode[\"F1\"] = 59] = \"F1\";\n    KeyCode[KeyCode[\"F2\"] = 60] = \"F2\";\n    KeyCode[KeyCode[\"F3\"] = 61] = \"F3\";\n    KeyCode[KeyCode[\"F4\"] = 62] = \"F4\";\n    KeyCode[KeyCode[\"F5\"] = 63] = \"F5\";\n    KeyCode[KeyCode[\"F6\"] = 64] = \"F6\";\n    KeyCode[KeyCode[\"F7\"] = 65] = \"F7\";\n    KeyCode[KeyCode[\"F8\"] = 66] = \"F8\";\n    KeyCode[KeyCode[\"F9\"] = 67] = \"F9\";\n    KeyCode[KeyCode[\"F10\"] = 68] = \"F10\";\n    KeyCode[KeyCode[\"F11\"] = 69] = \"F11\";\n    KeyCode[KeyCode[\"F12\"] = 70] = \"F12\";\n    KeyCode[KeyCode[\"F13\"] = 71] = \"F13\";\n    KeyCode[KeyCode[\"F14\"] = 72] = \"F14\";\n    KeyCode[KeyCode[\"F15\"] = 73] = \"F15\";\n    KeyCode[KeyCode[\"F16\"] = 74] = \"F16\";\n    KeyCode[KeyCode[\"F17\"] = 75] = \"F17\";\n    KeyCode[KeyCode[\"F18\"] = 76] = \"F18\";\n    KeyCode[KeyCode[\"F19\"] = 77] = \"F19\";\n    KeyCode[KeyCode[\"NumLock\"] = 78] = \"NumLock\";\n    KeyCode[KeyCode[\"ScrollLock\"] = 79] = \"ScrollLock\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ';:' key\n     */\n    KeyCode[KeyCode[\"US_SEMICOLON\"] = 80] = \"US_SEMICOLON\";\n    /**\n     * For any country/region, the '+' key\n     * For the US standard keyboard, the '=+' key\n     */\n    KeyCode[KeyCode[\"US_EQUAL\"] = 81] = \"US_EQUAL\";\n    /**\n     * For any country/region, the ',' key\n     * For the US standard keyboard, the ',<' key\n     */\n    KeyCode[KeyCode[\"US_COMMA\"] = 82] = \"US_COMMA\";\n    /**\n     * For any country/region, the '-' key\n     * For the US standard keyboard, the '-_' key\n     */\n    KeyCode[KeyCode[\"US_MINUS\"] = 83] = \"US_MINUS\";\n    /**\n     * For any country/region, the '.' key\n     * For the US standard keyboard, the '.>' key\n     */\n    KeyCode[KeyCode[\"US_DOT\"] = 84] = \"US_DOT\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '/?' key\n     */\n    KeyCode[KeyCode[\"US_SLASH\"] = 85] = \"US_SLASH\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '`~' key\n     */\n    KeyCode[KeyCode[\"US_BACKTICK\"] = 86] = \"US_BACKTICK\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '[{' key\n     */\n    KeyCode[KeyCode[\"US_OPEN_SQUARE_BRACKET\"] = 87] = \"US_OPEN_SQUARE_BRACKET\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '\\|' key\n     */\n    KeyCode[KeyCode[\"US_BACKSLASH\"] = 88] = \"US_BACKSLASH\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ']}' key\n     */\n    KeyCode[KeyCode[\"US_CLOSE_SQUARE_BRACKET\"] = 89] = \"US_CLOSE_SQUARE_BRACKET\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ''\"' key\n     */\n    KeyCode[KeyCode[\"US_QUOTE\"] = 90] = \"US_QUOTE\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     */\n    KeyCode[KeyCode[\"OEM_8\"] = 91] = \"OEM_8\";\n    /**\n     * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n     */\n    KeyCode[KeyCode[\"OEM_102\"] = 92] = \"OEM_102\";\n    KeyCode[KeyCode[\"NUMPAD_0\"] = 93] = \"NUMPAD_0\";\n    KeyCode[KeyCode[\"NUMPAD_1\"] = 94] = \"NUMPAD_1\";\n    KeyCode[KeyCode[\"NUMPAD_2\"] = 95] = \"NUMPAD_2\";\n    KeyCode[KeyCode[\"NUMPAD_3\"] = 96] = \"NUMPAD_3\";\n    KeyCode[KeyCode[\"NUMPAD_4\"] = 97] = \"NUMPAD_4\";\n    KeyCode[KeyCode[\"NUMPAD_5\"] = 98] = \"NUMPAD_5\";\n    KeyCode[KeyCode[\"NUMPAD_6\"] = 99] = \"NUMPAD_6\";\n    KeyCode[KeyCode[\"NUMPAD_7\"] = 100] = \"NUMPAD_7\";\n    KeyCode[KeyCode[\"NUMPAD_8\"] = 101] = \"NUMPAD_8\";\n    KeyCode[KeyCode[\"NUMPAD_9\"] = 102] = \"NUMPAD_9\";\n    KeyCode[KeyCode[\"NUMPAD_MULTIPLY\"] = 103] = \"NUMPAD_MULTIPLY\";\n    KeyCode[KeyCode[\"NUMPAD_ADD\"] = 104] = \"NUMPAD_ADD\";\n    KeyCode[KeyCode[\"NUMPAD_SEPARATOR\"] = 105] = \"NUMPAD_SEPARATOR\";\n    KeyCode[KeyCode[\"NUMPAD_SUBTRACT\"] = 106] = \"NUMPAD_SUBTRACT\";\n    KeyCode[KeyCode[\"NUMPAD_DECIMAL\"] = 107] = \"NUMPAD_DECIMAL\";\n    KeyCode[KeyCode[\"NUMPAD_DIVIDE\"] = 108] = \"NUMPAD_DIVIDE\";\n    /**\n     * Cover all key codes when IME is processing input.\n     */\n    KeyCode[KeyCode[\"KEY_IN_COMPOSITION\"] = 109] = \"KEY_IN_COMPOSITION\";\n    KeyCode[KeyCode[\"ABNT_C1\"] = 110] = \"ABNT_C1\";\n    KeyCode[KeyCode[\"ABNT_C2\"] = 111] = \"ABNT_C2\";\n    /**\n     * Placed last to cover the length of the enum.\n     * Please do not depend on this value!\n     */\n    KeyCode[KeyCode[\"MAX_VALUE\"] = 112] = \"MAX_VALUE\";\n})(KeyCode || (KeyCode = {}));\n/**\n * The direction of a selection.\n */\nexport var SelectionDirection;\n(function (SelectionDirection) {\n    /**\n     * The selection starts above where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"LTR\"] = 0] = \"LTR\";\n    /**\n     * The selection starts below where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"RTL\"] = 1] = \"RTL\";\n})(SelectionDirection || (SelectionDirection = {}));\nexport var ScrollbarVisibility;\n(function (ScrollbarVisibility) {\n    ScrollbarVisibility[ScrollbarVisibility[\"Auto\"] = 1] = \"Auto\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Hidden\"] = 2] = \"Hidden\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Visible\"] = 3] = \"Visible\";\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLinePreference;\n(function (EndOfLinePreference) {\n    /**\n     * Use the end of line character identified in the text buffer.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"TextDefined\"] = 0] = \"TextDefined\";\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"CRLF\"] = 2] = \"CRLF\";\n})(EndOfLinePreference || (EndOfLinePreference = {}));\n/**\n * The default end of line to use when instantiating models.\n */\nexport var DefaultEndOfLine;\n(function (DefaultEndOfLine) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"CRLF\"] = 2] = \"CRLF\";\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLineSequence;\n(function (EndOfLineSequence) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"LF\"] = 0] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"CRLF\"] = 1] = \"CRLF\";\n})(EndOfLineSequence || (EndOfLineSequence = {}));\n/**\n * Describes the behavior of decorations when typing/editing near their edges.\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\n */\nexport var TrackedRangeStickiness;\n(function (TrackedRangeStickiness) {\n    TrackedRangeStickiness[TrackedRangeStickiness[\"AlwaysGrowsWhenTypingAtEdges\"] = 0] = \"AlwaysGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"NeverGrowsWhenTypingAtEdges\"] = 1] = \"NeverGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingBefore\"] = 2] = \"GrowsOnlyWhenTypingBefore\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingAfter\"] = 3] = \"GrowsOnlyWhenTypingAfter\";\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\nexport var ScrollType;\n(function (ScrollType) {\n    ScrollType[ScrollType[\"Smooth\"] = 0] = \"Smooth\";\n    ScrollType[ScrollType[\"Immediate\"] = 1] = \"Immediate\";\n})(ScrollType || (ScrollType = {}));\n/**\n * Describes the reason the cursor has changed its position.\n */\nexport var CursorChangeReason;\n(function (CursorChangeReason) {\n    /**\n     * Unknown or not set.\n     */\n    CursorChangeReason[CursorChangeReason[\"NotSet\"] = 0] = \"NotSet\";\n    /**\n     * A `model.setValue()` was called.\n     */\n    CursorChangeReason[CursorChangeReason[\"ContentFlush\"] = 1] = \"ContentFlush\";\n    /**\n     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\n     */\n    CursorChangeReason[CursorChangeReason[\"RecoverFromMarkers\"] = 2] = \"RecoverFromMarkers\";\n    /**\n     * There was an explicit user gesture.\n     */\n    CursorChangeReason[CursorChangeReason[\"Explicit\"] = 3] = \"Explicit\";\n    /**\n     * There was a Paste.\n     */\n    CursorChangeReason[CursorChangeReason[\"Paste\"] = 4] = \"Paste\";\n    /**\n     * There was an Undo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Undo\"] = 5] = \"Undo\";\n    /**\n     * There was a Redo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Redo\"] = 6] = \"Redo\";\n})(CursorChangeReason || (CursorChangeReason = {}));\nexport var RenderMinimap;\n(function (RenderMinimap) {\n    RenderMinimap[RenderMinimap[\"None\"] = 0] = \"None\";\n    RenderMinimap[RenderMinimap[\"Small\"] = 1] = \"Small\";\n    RenderMinimap[RenderMinimap[\"Large\"] = 2] = \"Large\";\n    RenderMinimap[RenderMinimap[\"SmallBlocks\"] = 3] = \"SmallBlocks\";\n    RenderMinimap[RenderMinimap[\"LargeBlocks\"] = 4] = \"LargeBlocks\";\n})(RenderMinimap || (RenderMinimap = {}));\n/**\n * Describes how to indent wrapped lines.\n */\nexport var WrappingIndent;\n(function (WrappingIndent) {\n    /**\n     * No indentation => wrapped lines begin at column 1.\n     */\n    WrappingIndent[WrappingIndent[\"None\"] = 0] = \"None\";\n    /**\n     * Same => wrapped lines get the same indentation as the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Same\"] = 1] = \"Same\";\n    /**\n     * Indent => wrapped lines get +1 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Indent\"] = 2] = \"Indent\";\n    /**\n     * DeepIndent => wrapped lines get +2 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"DeepIndent\"] = 3] = \"DeepIndent\";\n})(WrappingIndent || (WrappingIndent = {}));\n/**\n * The kind of animation in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorBlinkingStyle;\n(function (TextEditorCursorBlinkingStyle) {\n    /**\n     * Hidden\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Hidden\"] = 0] = \"Hidden\";\n    /**\n     * Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Blink\"] = 1] = \"Blink\";\n    /**\n     * Blinking with smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Smooth\"] = 2] = \"Smooth\";\n    /**\n     * Blinking with prolonged filled state and smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Phase\"] = 3] = \"Phase\";\n    /**\n     * Expand collapse animation on the y axis\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Expand\"] = 4] = \"Expand\";\n    /**\n     * No-Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Solid\"] = 5] = \"Solid\";\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\n/**\n * The style in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorStyle;\n(function (TextEditorCursorStyle) {\n    /**\n     * As a vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Line\"] = 1] = \"Line\";\n    /**\n     * As a block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Block\"] = 2] = \"Block\";\n    /**\n     * As a horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Underline\"] = 3] = \"Underline\";\n    /**\n     * As a thin vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"LineThin\"] = 4] = \"LineThin\";\n    /**\n     * As an outlined block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"BlockOutline\"] = 5] = \"BlockOutline\";\n    /**\n     * As a thin horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"UnderlineThin\"] = 6] = \"UnderlineThin\";\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\nexport var RenderLineNumbersType;\n(function (RenderLineNumbersType) {\n    RenderLineNumbersType[RenderLineNumbersType[\"Off\"] = 0] = \"Off\";\n    RenderLineNumbersType[RenderLineNumbersType[\"On\"] = 1] = \"On\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Relative\"] = 2] = \"Relative\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Interval\"] = 3] = \"Interval\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Custom\"] = 4] = \"Custom\";\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\n/**\n * A positioning preference for rendering content widgets.\n */\nexport var ContentWidgetPositionPreference;\n(function (ContentWidgetPositionPreference) {\n    /**\n     * Place the content widget exactly at a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"EXACT\"] = 0] = \"EXACT\";\n    /**\n     * Place the content widget above a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"ABOVE\"] = 1] = \"ABOVE\";\n    /**\n     * Place the content widget below a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"BELOW\"] = 2] = \"BELOW\";\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\n/**\n * A positioning preference for rendering overlay widgets.\n */\nexport var OverlayWidgetPositionPreference;\n(function (OverlayWidgetPositionPreference) {\n    /**\n     * Position the overlay widget in the top right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_RIGHT_CORNER\"] = 0] = \"TOP_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the bottom right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"BOTTOM_RIGHT_CORNER\"] = 1] = \"BOTTOM_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the top center\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_CENTER\"] = 2] = \"TOP_CENTER\";\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\n/**\n * Type of hit element with the mouse in the editor.\n */\nexport var MouseTargetType;\n(function (MouseTargetType) {\n    /**\n     * Mouse is on top of an unknown element.\n     */\n    MouseTargetType[MouseTargetType[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n    /**\n     * Mouse is on top of the textarea used for input.\n     */\n    MouseTargetType[MouseTargetType[\"TEXTAREA\"] = 1] = \"TEXTAREA\";\n    /**\n     * Mouse is on top of the glyph margin\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_GLYPH_MARGIN\"] = 2] = \"GUTTER_GLYPH_MARGIN\";\n    /**\n     * Mouse is on top of the line numbers\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_NUMBERS\"] = 3] = \"GUTTER_LINE_NUMBERS\";\n    /**\n     * Mouse is on top of the line decorations\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_DECORATIONS\"] = 4] = \"GUTTER_LINE_DECORATIONS\";\n    /**\n     * Mouse is on top of the whitespace left in the gutter by a view zone.\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_VIEW_ZONE\"] = 5] = \"GUTTER_VIEW_ZONE\";\n    /**\n     * Mouse is on top of text in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_TEXT\"] = 6] = \"CONTENT_TEXT\";\n    /**\n     * Mouse is on top of empty space in the content (e.g. after line text or below last line)\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_EMPTY\"] = 7] = \"CONTENT_EMPTY\";\n    /**\n     * Mouse is on top of a view zone in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_VIEW_ZONE\"] = 8] = \"CONTENT_VIEW_ZONE\";\n    /**\n     * Mouse is on top of a content widget.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_WIDGET\"] = 9] = \"CONTENT_WIDGET\";\n    /**\n     * Mouse is on top of the decorations overview ruler.\n     */\n    MouseTargetType[MouseTargetType[\"OVERVIEW_RULER\"] = 10] = \"OVERVIEW_RULER\";\n    /**\n     * Mouse is on top of a scrollbar.\n     */\n    MouseTargetType[MouseTargetType[\"SCROLLBAR\"] = 11] = \"SCROLLBAR\";\n    /**\n     * Mouse is on top of an overlay widget.\n     */\n    MouseTargetType[MouseTargetType[\"OVERLAY_WIDGET\"] = 12] = \"OVERLAY_WIDGET\";\n    /**\n     * Mouse is outside of the editor.\n     */\n    MouseTargetType[MouseTargetType[\"OUTSIDE_EDITOR\"] = 13] = \"OUTSIDE_EDITOR\";\n})(MouseTargetType || (MouseTargetType = {}));\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nexport var IndentAction;\n(function (IndentAction) {\n    /**\n     * Insert new line and copy the previous line's indentation.\n     */\n    IndentAction[IndentAction[\"None\"] = 0] = \"None\";\n    /**\n     * Insert new line and indent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\n    /**\n     * Insert two new lines:\n     *  - the first one indented which will hold the cursor\n     *  - the second one at the same indentation level\n     */\n    IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\n    /**\n     * Insert new line and outdent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\n})(IndentAction || (IndentAction = {}));\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind[CompletionItemKind[\"Method\"] = 0] = \"Method\";\n    CompletionItemKind[CompletionItemKind[\"Function\"] = 1] = \"Function\";\n    CompletionItemKind[CompletionItemKind[\"Constructor\"] = 2] = \"Constructor\";\n    CompletionItemKind[CompletionItemKind[\"Field\"] = 3] = \"Field\";\n    CompletionItemKind[CompletionItemKind[\"Variable\"] = 4] = \"Variable\";\n    CompletionItemKind[CompletionItemKind[\"Class\"] = 5] = \"Class\";\n    CompletionItemKind[CompletionItemKind[\"Struct\"] = 6] = \"Struct\";\n    CompletionItemKind[CompletionItemKind[\"Interface\"] = 7] = \"Interface\";\n    CompletionItemKind[CompletionItemKind[\"Module\"] = 8] = \"Module\";\n    CompletionItemKind[CompletionItemKind[\"Property\"] = 9] = \"Property\";\n    CompletionItemKind[CompletionItemKind[\"Event\"] = 10] = \"Event\";\n    CompletionItemKind[CompletionItemKind[\"Operator\"] = 11] = \"Operator\";\n    CompletionItemKind[CompletionItemKind[\"Unit\"] = 12] = \"Unit\";\n    CompletionItemKind[CompletionItemKind[\"Value\"] = 13] = \"Value\";\n    CompletionItemKind[CompletionItemKind[\"Constant\"] = 14] = \"Constant\";\n    CompletionItemKind[CompletionItemKind[\"Enum\"] = 15] = \"Enum\";\n    CompletionItemKind[CompletionItemKind[\"EnumMember\"] = 16] = \"EnumMember\";\n    CompletionItemKind[CompletionItemKind[\"Keyword\"] = 17] = \"Keyword\";\n    CompletionItemKind[CompletionItemKind[\"Text\"] = 18] = \"Text\";\n    CompletionItemKind[CompletionItemKind[\"Color\"] = 19] = \"Color\";\n    CompletionItemKind[CompletionItemKind[\"File\"] = 20] = \"File\";\n    CompletionItemKind[CompletionItemKind[\"Reference\"] = 21] = \"Reference\";\n    CompletionItemKind[CompletionItemKind[\"Customcolor\"] = 22] = \"Customcolor\";\n    CompletionItemKind[CompletionItemKind[\"Folder\"] = 23] = \"Folder\";\n    CompletionItemKind[CompletionItemKind[\"TypeParameter\"] = 24] = \"TypeParameter\";\n    CompletionItemKind[CompletionItemKind[\"Snippet\"] = 25] = \"Snippet\";\n})(CompletionItemKind || (CompletionItemKind = {}));\nexport var CompletionItemInsertTextRule;\n(function (CompletionItemInsertTextRule) {\n    /**\n     * Adjust whitespace/indentation of multiline insert texts to\n     * match the current line indentation.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\n    /**\n     * `insertText` is a snippet.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\n/**\n * How a suggest provider was triggered.\n */\nexport var CompletionTriggerKind;\n(function (CompletionTriggerKind) {\n    CompletionTriggerKind[CompletionTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerCharacter\"] = 1] = \"TriggerCharacter\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerForIncompleteCompletions\"] = 2] = \"TriggerForIncompleteCompletions\";\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n    SymbolKind[SymbolKind[\"File\"] = 0] = \"File\";\n    SymbolKind[SymbolKind[\"Module\"] = 1] = \"Module\";\n    SymbolKind[SymbolKind[\"Namespace\"] = 2] = \"Namespace\";\n    SymbolKind[SymbolKind[\"Package\"] = 3] = \"Package\";\n    SymbolKind[SymbolKind[\"Class\"] = 4] = \"Class\";\n    SymbolKind[SymbolKind[\"Method\"] = 5] = \"Method\";\n    SymbolKind[SymbolKind[\"Property\"] = 6] = \"Property\";\n    SymbolKind[SymbolKind[\"Field\"] = 7] = \"Field\";\n    SymbolKind[SymbolKind[\"Constructor\"] = 8] = \"Constructor\";\n    SymbolKind[SymbolKind[\"Enum\"] = 9] = \"Enum\";\n    SymbolKind[SymbolKind[\"Interface\"] = 10] = \"Interface\";\n    SymbolKind[SymbolKind[\"Function\"] = 11] = \"Function\";\n    SymbolKind[SymbolKind[\"Variable\"] = 12] = \"Variable\";\n    SymbolKind[SymbolKind[\"Constant\"] = 13] = \"Constant\";\n    SymbolKind[SymbolKind[\"String\"] = 14] = \"String\";\n    SymbolKind[SymbolKind[\"Number\"] = 15] = \"Number\";\n    SymbolKind[SymbolKind[\"Boolean\"] = 16] = \"Boolean\";\n    SymbolKind[SymbolKind[\"Array\"] = 17] = \"Array\";\n    SymbolKind[SymbolKind[\"Object\"] = 18] = \"Object\";\n    SymbolKind[SymbolKind[\"Key\"] = 19] = \"Key\";\n    SymbolKind[SymbolKind[\"Null\"] = 20] = \"Null\";\n    SymbolKind[SymbolKind[\"EnumMember\"] = 21] = \"EnumMember\";\n    SymbolKind[SymbolKind[\"Struct\"] = 22] = \"Struct\";\n    SymbolKind[SymbolKind[\"Event\"] = 23] = \"Event\";\n    SymbolKind[SymbolKind[\"Operator\"] = 24] = \"Operator\";\n    SymbolKind[SymbolKind[\"TypeParameter\"] = 25] = \"TypeParameter\";\n})(SymbolKind || (SymbolKind = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nvar Selection = /** @class */ (function (_super) {\n    __extends(Selection, _super);\n    function Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n        var _this = _super.call(this, selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) || this;\n        _this.selectionStartLineNumber = selectionStartLineNumber;\n        _this.selectionStartColumn = selectionStartColumn;\n        _this.positionLineNumber = positionLineNumber;\n        _this.positionColumn = positionColumn;\n        return _this;\n    }\n    /**\n     * Clone this selection.\n     */\n    Selection.prototype.clone = function () {\n        return new Selection(this.selectionStartLineNumber, this.selectionStartColumn, this.positionLineNumber, this.positionColumn);\n    };\n    /**\n     * Transform to a human-readable representation.\n     */\n    Selection.prototype.toString = function () {\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n    };\n    /**\n     * Test if equals other selection.\n     */\n    Selection.prototype.equalsSelection = function (other) {\n        return (Selection.selectionsEqual(this, other));\n    };\n    /**\n     * Test if the two selections are equal.\n     */\n    Selection.selectionsEqual = function (a, b) {\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n            a.selectionStartColumn === b.selectionStartColumn &&\n            a.positionLineNumber === b.positionLineNumber &&\n            a.positionColumn === b.positionColumn);\n    };\n    /**\n     * Get directions (LTR or RTL).\n     */\n    Selection.prototype.getDirection = function () {\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n            return 0 /* LTR */;\n        }\n        return 1 /* RTL */;\n    };\n    /**\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n     */\n    Selection.prototype.setEndPosition = function (endLineNumber, endColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n    };\n    /**\n     * Get the position at `positionLineNumber` and `positionColumn`.\n     */\n    Selection.prototype.getPosition = function () {\n        return new Position(this.positionLineNumber, this.positionColumn);\n    };\n    /**\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n     */\n    Selection.prototype.setStartPosition = function (startLineNumber, startColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n        }\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n    };\n    // ----\n    /**\n     * Create a `Selection` from one or two positions\n     */\n    Selection.fromPositions = function (start, end) {\n        if (end === void 0) { end = start; }\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n    };\n    /**\n     * Create a `Selection` from an `ISelection`.\n     */\n    Selection.liftSelection = function (sel) {\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n    };\n    /**\n     * `a` equals `b`.\n     */\n    Selection.selectionsArrEqual = function (a, b) {\n        if (a && !b || !a && b) {\n            return false;\n        }\n        if (!a && !b) {\n            return true;\n        }\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (var i = 0, len = a.length; i < len; i++) {\n            if (!this.selectionsEqual(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * Test if `obj` is an `ISelection`.\n     */\n    Selection.isISelection = function (obj) {\n        return (obj\n            && (typeof obj.selectionStartLineNumber === 'number')\n            && (typeof obj.selectionStartColumn === 'number')\n            && (typeof obj.positionLineNumber === 'number')\n            && (typeof obj.positionColumn === 'number'));\n    };\n    /**\n     * Create with a direction.\n     */\n    Selection.createWithDirection = function (startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n        if (direction === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n    };\n    return Selection;\n}(Range));\nexport { Selection };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar Token = /** @class */ (function () {\n    function Token(offset, type, language) {\n        this.offset = offset | 0; // @perf\n        this.type = type;\n        this.language = language;\n    }\n    Token.prototype.toString = function () {\n        return '(' + this.offset + ', ' + this.type + ')';\n    };\n    return Token;\n}());\nexport { Token };\nvar TokenizationResult = /** @class */ (function () {\n    function TokenizationResult(tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n    return TokenizationResult;\n}());\nexport { TokenizationResult };\nvar TokenizationResult2 = /** @class */ (function () {\n    function TokenizationResult2(tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n    return TokenizationResult2;\n}());\nexport { TokenizationResult2 };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport './promise-polyfill/polyfill.js';\nimport { CancellationTokenSource } from '../../../base/common/cancellation.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { KeyChord } from '../../../base/common/keyCodes.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { Token } from '../core/token.js';\nimport * as standaloneEnums from './standaloneEnums.js';\nvar KeyMod = /** @class */ (function () {\n    function KeyMod() {\n    }\n    KeyMod.chord = function (firstPart, secondPart) {\n        return KeyChord(firstPart, secondPart);\n    };\n    KeyMod.CtrlCmd = 2048 /* CtrlCmd */;\n    KeyMod.Shift = 1024 /* Shift */;\n    KeyMod.Alt = 512 /* Alt */;\n    KeyMod.WinCtrl = 256 /* WinCtrl */;\n    return KeyMod;\n}());\nexport { KeyMod };\nexport function createMonacoBaseAPI() {\n    return {\n        editor: undefined,\n        languages: undefined,\n        CancellationTokenSource: CancellationTokenSource,\n        Emitter: Emitter,\n        KeyCode: standaloneEnums.KeyCode,\n        KeyMod: KeyMod,\n        Position: Position,\n        Range: Range,\n        Selection: Selection,\n        SelectionDirection: standaloneEnums.SelectionDirection,\n        MarkerSeverity: standaloneEnums.MarkerSeverity,\n        MarkerTag: standaloneEnums.MarkerTag,\n        Uri: URI,\n        Token: Token\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { mergeSort } from '../../../base/common/arrays.js';\nimport { stringDiff } from '../../../base/common/diff/diff.js';\nimport { FIN } from '../../../base/common/iterator.js';\nimport { globals } from '../../../base/common/platform.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { DiffComputer } from '../diff/diffComputer.js';\nimport { MirrorTextModel as BaseMirrorModel } from '../model/mirrorTextModel.js';\nimport { ensureValidWordDefinition, getWordAtText } from '../model/wordHelper.js';\nimport { computeLinks } from '../modes/linkComputer.js';\nimport { BasicInplaceReplace } from '../modes/supports/inplaceReplaceSupport.js';\nimport { createMonacoBaseAPI } from '../standalone/standaloneBase.js';\nimport { getAllPropertyNames } from '../../../base/common/types.js';\n/**\n * @internal\n */\nvar MirrorModel = /** @class */ (function (_super) {\n    __extends(MirrorModel, _super);\n    function MirrorModel() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Object.defineProperty(MirrorModel.prototype, \"uri\", {\n        get: function () {\n            return this._uri;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MirrorModel.prototype, \"version\", {\n        get: function () {\n            return this._versionId;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MirrorModel.prototype, \"eol\", {\n        get: function () {\n            return this._eol;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MirrorModel.prototype.getValue = function () {\n        return this.getText();\n    };\n    MirrorModel.prototype.getLinesContent = function () {\n        return this._lines.slice(0);\n    };\n    MirrorModel.prototype.getLineCount = function () {\n        return this._lines.length;\n    };\n    MirrorModel.prototype.getLineContent = function (lineNumber) {\n        return this._lines[lineNumber - 1];\n    };\n    MirrorModel.prototype.getWordAtPosition = function (position, wordDefinition) {\n        var wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);\n        if (wordAtText) {\n            return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n        }\n        return null;\n    };\n    MirrorModel.prototype.getWordUntilPosition = function (position, wordDefinition) {\n        var wordAtPosition = this.getWordAtPosition(position, wordDefinition);\n        if (!wordAtPosition) {\n            return {\n                word: '',\n                startColumn: position.column,\n                endColumn: position.column\n            };\n        }\n        return {\n            word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),\n            startColumn: wordAtPosition.startColumn,\n            endColumn: position.column\n        };\n    };\n    MirrorModel.prototype.createWordIterator = function (wordDefinition) {\n        var _this = this;\n        var obj;\n        var lineNumber = 0;\n        var lineText;\n        var wordRangesIdx = 0;\n        var wordRanges = [];\n        var next = function () {\n            if (wordRangesIdx < wordRanges.length) {\n                var value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n                wordRangesIdx += 1;\n                if (!obj) {\n                    obj = { done: false, value: value };\n                }\n                else {\n                    obj.value = value;\n                }\n                return obj;\n            }\n            else if (lineNumber >= _this._lines.length) {\n                return FIN;\n            }\n            else {\n                lineText = _this._lines[lineNumber];\n                wordRanges = _this._wordenize(lineText, wordDefinition);\n                wordRangesIdx = 0;\n                lineNumber += 1;\n                return next();\n            }\n        };\n        return { next: next };\n    };\n    MirrorModel.prototype.getLineWords = function (lineNumber, wordDefinition) {\n        var content = this._lines[lineNumber - 1];\n        var ranges = this._wordenize(content, wordDefinition);\n        var words = [];\n        for (var _i = 0, ranges_1 = ranges; _i < ranges_1.length; _i++) {\n            var range = ranges_1[_i];\n            words.push({\n                word: content.substring(range.start, range.end),\n                startColumn: range.start + 1,\n                endColumn: range.end + 1\n            });\n        }\n        return words;\n    };\n    MirrorModel.prototype._wordenize = function (content, wordDefinition) {\n        var result = [];\n        var match;\n        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n        while (match = wordDefinition.exec(content)) {\n            if (match[0].length === 0) {\n                // it did match the empty string\n                break;\n            }\n            result.push({ start: match.index, end: match.index + match[0].length });\n        }\n        return result;\n    };\n    MirrorModel.prototype.getValueInRange = function (range) {\n        range = this._validateRange(range);\n        if (range.startLineNumber === range.endLineNumber) {\n            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n        }\n        var lineEnding = this._eol;\n        var startLineIndex = range.startLineNumber - 1;\n        var endLineIndex = range.endLineNumber - 1;\n        var resultLines = [];\n        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n        for (var i = startLineIndex + 1; i < endLineIndex; i++) {\n            resultLines.push(this._lines[i]);\n        }\n        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n        return resultLines.join(lineEnding);\n    };\n    MirrorModel.prototype.offsetAt = function (position) {\n        position = this._validatePosition(position);\n        this._ensureLineStarts();\n        return this._lineStarts.getAccumulatedValue(position.lineNumber - 2) + (position.column - 1);\n    };\n    MirrorModel.prototype.positionAt = function (offset) {\n        offset = Math.floor(offset);\n        offset = Math.max(0, offset);\n        this._ensureLineStarts();\n        var out = this._lineStarts.getIndexOf(offset);\n        var lineLength = this._lines[out.index].length;\n        // Ensure we return a valid position\n        return {\n            lineNumber: 1 + out.index,\n            column: 1 + Math.min(out.remainder, lineLength)\n        };\n    };\n    MirrorModel.prototype._validateRange = function (range) {\n        var start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n        var end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n        if (start.lineNumber !== range.startLineNumber\n            || start.column !== range.startColumn\n            || end.lineNumber !== range.endLineNumber\n            || end.column !== range.endColumn) {\n            return {\n                startLineNumber: start.lineNumber,\n                startColumn: start.column,\n                endLineNumber: end.lineNumber,\n                endColumn: end.column\n            };\n        }\n        return range;\n    };\n    MirrorModel.prototype._validatePosition = function (position) {\n        if (!Position.isIPosition(position)) {\n            throw new Error('bad position');\n        }\n        var lineNumber = position.lineNumber, column = position.column;\n        var hasChanged = false;\n        if (lineNumber < 1) {\n            lineNumber = 1;\n            column = 1;\n            hasChanged = true;\n        }\n        else if (lineNumber > this._lines.length) {\n            lineNumber = this._lines.length;\n            column = this._lines[lineNumber - 1].length + 1;\n            hasChanged = true;\n        }\n        else {\n            var maxCharacter = this._lines[lineNumber - 1].length + 1;\n            if (column < 1) {\n                column = 1;\n                hasChanged = true;\n            }\n            else if (column > maxCharacter) {\n                column = maxCharacter;\n                hasChanged = true;\n            }\n        }\n        if (!hasChanged) {\n            return position;\n        }\n        else {\n            return { lineNumber: lineNumber, column: column };\n        }\n    };\n    return MirrorModel;\n}(BaseMirrorModel));\n/**\n * @internal\n */\nvar BaseEditorSimpleWorker = /** @class */ (function () {\n    function BaseEditorSimpleWorker(foreignModuleFactory) {\n        this._foreignModuleFactory = foreignModuleFactory;\n        this._foreignModule = null;\n    }\n    // ---- BEGIN diff --------------------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.computeDiff = function (originalUrl, modifiedUrl, ignoreTrimWhitespace) {\n        var original = this._getModel(originalUrl);\n        var modified = this._getModel(modifiedUrl);\n        if (!original || !modified) {\n            return Promise.resolve(null);\n        }\n        var originalLines = original.getLinesContent();\n        var modifiedLines = modified.getLinesContent();\n        var diffComputer = new DiffComputer(originalLines, modifiedLines, {\n            shouldComputeCharChanges: true,\n            shouldPostProcessCharChanges: true,\n            shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n            shouldMakePrettyDiff: true\n        });\n        var changes = diffComputer.computeDiff();\n        var identical = (changes.length > 0 ? false : this._modelsAreIdentical(original, modified));\n        return Promise.resolve({\n            identical: identical,\n            changes: changes\n        });\n    };\n    BaseEditorSimpleWorker.prototype._modelsAreIdentical = function (original, modified) {\n        var originalLineCount = original.getLineCount();\n        var modifiedLineCount = modified.getLineCount();\n        if (originalLineCount !== modifiedLineCount) {\n            return false;\n        }\n        for (var line = 1; line <= originalLineCount; line++) {\n            var originalLine = original.getLineContent(line);\n            var modifiedLine = modified.getLineContent(line);\n            if (originalLine !== modifiedLine) {\n                return false;\n            }\n        }\n        return true;\n    };\n    BaseEditorSimpleWorker.prototype.computeMoreMinimalEdits = function (modelUrl, edits) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(edits);\n        }\n        var result = [];\n        var lastEol = undefined;\n        edits = mergeSort(edits, function (a, b) {\n            if (a.range && b.range) {\n                return Range.compareRangesUsingStarts(a.range, b.range);\n            }\n            // eol only changes should go to the end\n            var aRng = a.range ? 0 : 1;\n            var bRng = b.range ? 0 : 1;\n            return aRng - bRng;\n        });\n        for (var _i = 0, edits_1 = edits; _i < edits_1.length; _i++) {\n            var _a = edits_1[_i], range = _a.range, text = _a.text, eol = _a.eol;\n            if (typeof eol === 'number') {\n                lastEol = eol;\n            }\n            if (Range.isEmpty(range) && !text) {\n                // empty change\n                continue;\n            }\n            var original = model.getValueInRange(range);\n            text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n            if (original === text) {\n                // noop\n                continue;\n            }\n            // make sure diff won't take too long\n            if (Math.max(text.length, original.length) > BaseEditorSimpleWorker._diffLimit) {\n                result.push({ range: range, text: text });\n                continue;\n            }\n            // compute diff between original and edit.text\n            var changes = stringDiff(original, text, false);\n            var editOffset = model.offsetAt(Range.lift(range).getStartPosition());\n            for (var _b = 0, changes_1 = changes; _b < changes_1.length; _b++) {\n                var change = changes_1[_b];\n                var start = model.positionAt(editOffset + change.originalStart);\n                var end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n                var newEdit = {\n                    text: text.substr(change.modifiedStart, change.modifiedLength),\n                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n                };\n                if (model.getValueInRange(newEdit.range) !== newEdit.text) {\n                    result.push(newEdit);\n                }\n            }\n        }\n        if (typeof lastEol === 'number') {\n            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\n        }\n        return Promise.resolve(result);\n    };\n    // ---- END minimal edits ---------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.computeLinks = function (modelUrl) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        return Promise.resolve(computeLinks(model));\n    };\n    BaseEditorSimpleWorker.prototype.textualSuggest = function (modelUrl, position, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        var suggestions = [];\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        var currentWord = model.getWordUntilPosition(position, wordDefRegExp);\n        var seen = Object.create(null);\n        seen[currentWord.word] = true;\n        for (var iter = model.createWordIterator(wordDefRegExp), e = iter.next(); !e.done && suggestions.length <= BaseEditorSimpleWorker._suggestionsLimit; e = iter.next()) {\n            var word = e.value;\n            if (seen[word]) {\n                continue;\n            }\n            seen[word] = true;\n            if (!isNaN(Number(word))) {\n                continue;\n            }\n            suggestions.push({\n                kind: 18 /* Text */,\n                label: word,\n                insertText: word,\n                range: { startLineNumber: position.lineNumber, startColumn: currentWord.startColumn, endLineNumber: position.lineNumber, endColumn: currentWord.endColumn }\n            });\n        }\n        return Promise.resolve({ suggestions: suggestions });\n    };\n    // ---- END suggest --------------------------------------------------------------------------\n    //#region -- word ranges --\n    BaseEditorSimpleWorker.prototype.computeWordRanges = function (modelUrl, range, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(Object.create(null));\n        }\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        var result = Object.create(null);\n        for (var line = range.startLineNumber; line < range.endLineNumber; line++) {\n            var words = model.getLineWords(line, wordDefRegExp);\n            for (var _i = 0, words_1 = words; _i < words_1.length; _i++) {\n                var word = words_1[_i];\n                if (!isNaN(Number(word.word))) {\n                    continue;\n                }\n                var array = result[word.word];\n                if (!array) {\n                    array = [];\n                    result[word.word] = array;\n                }\n                array.push({\n                    startLineNumber: line,\n                    startColumn: word.startColumn,\n                    endLineNumber: line,\n                    endColumn: word.endColumn\n                });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    //#endregion\n    BaseEditorSimpleWorker.prototype.navigateValueSet = function (modelUrl, range, up, wordDef, wordDefFlags) {\n        var model = this._getModel(modelUrl);\n        if (!model) {\n            return Promise.resolve(null);\n        }\n        var wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n        if (range.startColumn === range.endColumn) {\n            range = {\n                startLineNumber: range.startLineNumber,\n                startColumn: range.startColumn,\n                endLineNumber: range.endLineNumber,\n                endColumn: range.endColumn + 1\n            };\n        }\n        var selectionText = model.getValueInRange(range);\n        var wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n        if (!wordRange) {\n            return Promise.resolve(null);\n        }\n        var word = model.getValueInRange(wordRange);\n        var result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n        return Promise.resolve(result);\n    };\n    // ---- BEGIN foreign module support --------------------------------------------------------------------------\n    BaseEditorSimpleWorker.prototype.loadForeignModule = function (moduleId, createData) {\n        var _this = this;\n        var ctx = {\n            getMirrorModels: function () {\n                return _this._getModels();\n            }\n        };\n        if (this._foreignModuleFactory) {\n            this._foreignModule = this._foreignModuleFactory(ctx, createData);\n            // static foreing module\n            var methods = [];\n            for (var _i = 0, _a = getAllPropertyNames(this._foreignModule); _i < _a.length; _i++) {\n                var prop = _a[_i];\n                if (typeof this._foreignModule[prop] === 'function') {\n                    methods.push(prop);\n                }\n            }\n            return Promise.resolve(methods);\n        }\n        // ESM-comment-begin\n        // \t\treturn new Promise<any>((resolve, reject) => {\n        // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n        // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n        // \n        // \t\t\t\tlet methods: string[] = [];\n        // \t\t\t\tfor (const prop of getAllPropertyNames(this._foreignModule)) {\n        // \t\t\t\t\tif (typeof this._foreignModule[prop] === 'function') {\n        // \t\t\t\t\t\tmethods.push(prop);\n        // \t\t\t\t\t}\n        // \t\t\t\t}\n        // \n        // \t\t\t\tresolve(methods);\n        // \n        // \t\t\t}, reject);\n        // \t\t});\n        // ESM-comment-end\n        // ESM-uncomment-begin\n        return Promise.reject(new Error(\"Unexpected usage\"));\n        // ESM-uncomment-end\n    };\n    // foreign method request\n    BaseEditorSimpleWorker.prototype.fmr = function (method, args) {\n        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    };\n    // ---- END diff --------------------------------------------------------------------------\n    // ---- BEGIN minimal edits ---------------------------------------------------------------\n    BaseEditorSimpleWorker._diffLimit = 10000;\n    // ---- BEGIN suggest --------------------------------------------------------------------------\n    BaseEditorSimpleWorker._suggestionsLimit = 10000;\n    return BaseEditorSimpleWorker;\n}());\nexport { BaseEditorSimpleWorker };\n/**\n * @internal\n */\nvar EditorSimpleWorkerImpl = /** @class */ (function (_super) {\n    __extends(EditorSimpleWorkerImpl, _super);\n    function EditorSimpleWorkerImpl(foreignModuleFactory) {\n        var _this = _super.call(this, foreignModuleFactory) || this;\n        _this._models = Object.create(null);\n        return _this;\n    }\n    EditorSimpleWorkerImpl.prototype.dispose = function () {\n        this._models = Object.create(null);\n    };\n    EditorSimpleWorkerImpl.prototype._getModel = function (uri) {\n        return this._models[uri];\n    };\n    EditorSimpleWorkerImpl.prototype._getModels = function () {\n        var _this = this;\n        var all = [];\n        Object.keys(this._models).forEach(function (key) { return all.push(_this._models[key]); });\n        return all;\n    };\n    EditorSimpleWorkerImpl.prototype.acceptNewModel = function (data) {\n        this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\n    };\n    EditorSimpleWorkerImpl.prototype.acceptModelChanged = function (strURL, e) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        var model = this._models[strURL];\n        model.onEvents(e);\n    };\n    EditorSimpleWorkerImpl.prototype.acceptRemovedModel = function (strURL) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        delete this._models[strURL];\n    };\n    return EditorSimpleWorkerImpl;\n}(BaseEditorSimpleWorker));\nexport { EditorSimpleWorkerImpl };\n/**\n * Called on the worker side\n * @internal\n */\nexport function create() {\n    return new EditorSimpleWorkerImpl(null);\n}\nif (typeof importScripts === 'function') {\n    // Running in a web worker\n    globals.monaco = createMonacoBaseAPI();\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';\nimport { EditorSimpleWorkerImpl } from './common/services/editorSimpleWorker.js';\nvar initialized = false;\nexport function initialize(foreignModule) {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    var editorWorker = new EditorSimpleWorkerImpl(foreignModule);\n    var simpleWorker = new SimpleWorkerServer(function (msg) {\n        self.postMessage(msg);\n    }, editorWorker);\n    self.onmessage = function (e) {\n        simpleWorker.onmessage(e.data);\n    };\n}\nself.onmessage = function (e) {\n    // Ignore first message in this case and initialize if not yet initialized\n    if (!initialized) {\n        initialize(null);\n    }\n};\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/**\r\n * The Position namespace provides helper functions to work with\r\n * [Position](#Position) literals.\r\n */\r\nexport 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 || (Position = {}));\r\n/**\r\n * The Range namespace provides helper functions to work with\r\n * [Range](#Range) literals.\r\n */\r\nexport 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 || (Range = {}));\r\n/**\r\n * The Location namespace provides helper functions to work with\r\n * [Location](#Location) literals.\r\n */\r\nexport 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 || (Location = {}));\r\n/**\r\n * The LocationLink namespace provides helper functions to work with\r\n * [LocationLink](#LocationLink) literals.\r\n */\r\nexport 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 || (LocationLink = {}));\r\n/**\r\n * The Color namespace provides helper functions to work with\r\n * [Color](#Color) literals.\r\n */\r\nexport 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 || (Color = {}));\r\n/**\r\n * The ColorInformation namespace provides helper functions to work with\r\n * [ColorInformation](#ColorInformation) literals.\r\n */\r\nexport 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 || (ColorInformation = {}));\r\n/**\r\n * The Color namespace provides helper functions to work with\r\n * [ColorPresentation](#ColorPresentation) literals.\r\n */\r\nexport 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 || (ColorPresentation = {}));\r\n/**\r\n * Enum of known range kinds\r\n */\r\nexport 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 || (FoldingRangeKind = {}));\r\n/**\r\n * The folding range namespace provides helper functions to work with\r\n * [FoldingRange](#FoldingRange) literals.\r\n */\r\nexport 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 || (FoldingRange = {}));\r\n/**\r\n * The DiagnosticRelatedInformation namespace provides helper functions to work with\r\n * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.\r\n */\r\nexport 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 || (DiagnosticRelatedInformation = {}));\r\n/**\r\n * The diagnostic's severity.\r\n */\r\nexport 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 || (DiagnosticSeverity = {}));\r\n/**\r\n * The Diagnostic namespace provides helper functions to work with\r\n * [Diagnostic](#Diagnostic) literals.\r\n */\r\nexport 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 || (Diagnostic = {}));\r\n/**\r\n * The Command namespace provides helper functions to work with\r\n * [Command](#Command) literals.\r\n */\r\nexport 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 || (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\nexport 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 || (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\nexport 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 || (TextDocumentEdit = {}));\r\nexport 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 || (CreateFile = {}));\r\nexport 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 || (RenameFile = {}));\r\nexport 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 || (DeleteFile = {}));\r\nexport 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 || (WorkspaceEdit = {}));\r\nvar 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\nvar 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\nexport { WorkspaceChange };\r\n/**\r\n * The TextDocumentIdentifier namespace provides helper functions to work with\r\n * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.\r\n */\r\nexport 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 || (TextDocumentIdentifier = {}));\r\n/**\r\n * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\r\n * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.\r\n */\r\nexport 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 || (VersionedTextDocumentIdentifier = {}));\r\n/**\r\n * The TextDocumentItem namespace provides helper functions to work with\r\n * [TextDocumentItem](#TextDocumentItem) literals.\r\n */\r\nexport 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 || (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\nexport 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 || (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 || (MarkupKind = {}));\r\nexport 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 || (MarkupContent = {}));\r\n/**\r\n * The kind of a completion entry.\r\n */\r\nexport 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 || (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\nexport 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 || (InsertTextFormat = {}));\r\n/**\r\n * The CompletionItem namespace provides functions to deal with\r\n * completion items.\r\n */\r\nexport 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 || (CompletionItem = {}));\r\n/**\r\n * The CompletionList namespace provides functions to deal with\r\n * completion lists.\r\n */\r\nexport 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 || (CompletionList = {}));\r\nexport 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 || (MarkedString = {}));\r\nexport 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 || (Hover = {}));\r\n/**\r\n * The ParameterInformation namespace provides helper functions to work with\r\n * [ParameterInformation](#ParameterInformation) literals.\r\n */\r\nexport 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    ;\r\n})(ParameterInformation || (ParameterInformation = {}));\r\n/**\r\n * The SignatureInformation namespace provides helper functions to work with\r\n * [SignatureInformation](#SignatureInformation) literals.\r\n */\r\nexport 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 || (SignatureInformation = {}));\r\n/**\r\n * A document highlight kind.\r\n */\r\nexport 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 || (DocumentHighlightKind = {}));\r\n/**\r\n * DocumentHighlight namespace to provide helper functions to work with\r\n * [DocumentHighlight](#DocumentHighlight) literals.\r\n */\r\nexport 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 || (DocumentHighlight = {}));\r\n/**\r\n * A symbol kind.\r\n */\r\nexport 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 || (SymbolKind = {}));\r\nexport 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 || (SymbolInformation = {}));\r\n/**\r\n * Represents programming constructs like variables, classes, interfaces etc.\r\n * that appear in a document. Document symbols can be hierarchical and they\r\n * have two ranges: one that encloses its definition and one that points to\r\n * its most interesting range, e.g. the range of an identifier.\r\n */\r\nvar DocumentSymbol = /** @class */ (function () {\r\n    function DocumentSymbol() {\r\n    }\r\n    return DocumentSymbol;\r\n}());\r\nexport { 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 || (DocumentSymbol = {}));\r\n/**\r\n * A set of predefined code action kinds\r\n */\r\nexport var CodeActionKind;\r\n(function (CodeActionKind) {\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})(CodeActionKind || (CodeActionKind = {}));\r\n/**\r\n * The CodeActionContext namespace provides helper functions to work with\r\n * [CodeActionContext](#CodeActionContext) literals.\r\n */\r\nexport 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 || (CodeActionContext = {}));\r\nexport 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 null) {\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.edit === void 0 || WorkspaceEdit.is(candidate.edit));\r\n    }\r\n    CodeAction.is = is;\r\n})(CodeAction || (CodeAction = {}));\r\n/**\r\n * The CodeLens namespace provides helper functions to work with\r\n * [CodeLens](#CodeLens) literals.\r\n */\r\nexport 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        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 || (CodeLens = {}));\r\n/**\r\n * The FormattingOptions namespace provides helper functions to work with\r\n * [FormattingOptions](#FormattingOptions) literals.\r\n */\r\nexport 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 || (FormattingOptions = {}));\r\n/**\r\n * A document link is a range in a text document that links to an internal or external resource, like another\r\n * text document or a web site.\r\n */\r\nvar DocumentLink = /** @class */ (function () {\r\n    function DocumentLink() {\r\n    }\r\n    return DocumentLink;\r\n}());\r\nexport { DocumentLink };\r\n/**\r\n * The DocumentLink namespace provides helper functions to work with\r\n * [DocumentLink](#DocumentLink) literals.\r\n */\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 || (DocumentLink = {}));\r\nexport var EOL = ['\\n', '\\r\\n', '\\r'];\r\nexport 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 || (TextDocument = {}));\r\n/**\r\n * Represents reasons why a text document is saved.\r\n */\r\nexport var TextDocumentSaveReason;\r\n(function (TextDocumentSaveReason) {\r\n    /**\r\n     * Manually triggered, e.g. by the user pressing save, by starting debugging,\r\n     * or by an API call.\r\n     */\r\n    TextDocumentSaveReason.Manual = 1;\r\n    /**\r\n     * Automatic after a delay.\r\n     */\r\n    TextDocumentSaveReason.AfterDelay = 2;\r\n    /**\r\n     * When the editor lost focus.\r\n     */\r\n    TextDocumentSaveReason.FocusOut = 3;\r\n})(TextDocumentSaveReason || (TextDocumentSaveReason = {}));\r\nvar 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 = null;\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 = null;\r\n    };\r\n    FullTextDocument.prototype.getLineOffsets = function () {\r\n        if (this._lineOffsets === null) {\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\nvar 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","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport { createScanner } from './scanner.js';\nvar ParseOptions;\n(function (ParseOptions) {\n    ParseOptions.DEFAULT = {\n        allowTrailingComma: false\n    };\n})(ParseOptions || (ParseOptions = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport function getLocation(text, position) {\n    var segments = []; // strings or numbers\n    var earlyReturnException = new Object();\n    var previousNode = void 0;\n    var previousNodeInst = {\n        value: {},\n        offset: 0,\n        length: 0,\n        type: 'object',\n        parent: void 0\n    };\n    var isAtPropertyKey = false;\n    function setPreviousNode(value, offset, length, type) {\n        previousNodeInst.value = value;\n        previousNodeInst.offset = offset;\n        previousNodeInst.length = length;\n        previousNodeInst.type = type;\n        previousNodeInst.colonOffset = void 0;\n        previousNode = previousNodeInst;\n    }\n    try {\n        visit(text, {\n            onObjectBegin: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = void 0;\n                isAtPropertyKey = position > offset;\n                segments.push(''); // push a placeholder (will be replaced)\n            },\n            onObjectProperty: function (name, offset, length) {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(name, offset, length, 'property');\n                segments[segments.length - 1] = name;\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onObjectEnd: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = void 0;\n                segments.pop();\n            },\n            onArrayBegin: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = void 0;\n                segments.push(0);\n            },\n            onArrayEnd: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = void 0;\n                segments.pop();\n            },\n            onLiteralValue: function (value, offset, length) {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(value, offset, length, getLiteralNodeType(value));\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onSeparator: function (sep, offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                if (sep === ':' && previousNode && previousNode.type === 'property') {\n                    previousNode.colonOffset = offset;\n                    isAtPropertyKey = false;\n                    previousNode = void 0;\n                }\n                else if (sep === ',') {\n                    var last = segments[segments.length - 1];\n                    if (typeof last === 'number') {\n                        segments[segments.length - 1] = last + 1;\n                    }\n                    else {\n                        isAtPropertyKey = true;\n                        segments[segments.length - 1] = '';\n                    }\n                    previousNode = void 0;\n                }\n            }\n        });\n    }\n    catch (e) {\n        if (e !== earlyReturnException) {\n            throw e;\n        }\n    }\n    return {\n        path: segments,\n        previousNode: previousNode,\n        isAtPropertyKey: isAtPropertyKey,\n        matches: function (pattern) {\n            var k = 0;\n            for (var i = 0; k < pattern.length && i < segments.length; i++) {\n                if (pattern[k] === segments[i] || pattern[k] === '*') {\n                    k++;\n                }\n                else if (pattern[k] !== '**') {\n                    return false;\n                }\n            }\n            return k === pattern.length;\n        }\n    };\n}\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore always check the errors list to find out if the input was valid.\n */\nexport function parse(text, errors, options) {\n    if (errors === void 0) { errors = []; }\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var currentProperty = null;\n    var currentParent = [];\n    var previousParents = [];\n    function onValue(value) {\n        if (Array.isArray(currentParent)) {\n            currentParent.push(value);\n        }\n        else if (currentProperty) {\n            currentParent[currentProperty] = value;\n        }\n    }\n    var visitor = {\n        onObjectBegin: function () {\n            var object = {};\n            onValue(object);\n            previousParents.push(currentParent);\n            currentParent = object;\n            currentProperty = null;\n        },\n        onObjectProperty: function (name) {\n            currentProperty = name;\n        },\n        onObjectEnd: function () {\n            currentParent = previousParents.pop();\n        },\n        onArrayBegin: function () {\n            var array = [];\n            onValue(array);\n            previousParents.push(currentParent);\n            currentParent = array;\n            currentProperty = null;\n        },\n        onArrayEnd: function () {\n            currentParent = previousParents.pop();\n        },\n        onLiteralValue: onValue,\n        onError: function (error, offset, length) {\n            errors.push({ error: error, offset: offset, length: length });\n        }\n    };\n    visit(text, visitor, options);\n    return currentParent[0];\n}\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport function parseTree(text, errors, options) {\n    if (errors === void 0) { errors = []; }\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: void 0 }; // artificial root\n    function ensurePropertyComplete(endOffset) {\n        if (currentParent.type === 'property') {\n            currentParent.length = endOffset - currentParent.offset;\n            currentParent = currentParent.parent;\n        }\n    }\n    function onValue(valueNode) {\n        currentParent.children.push(valueNode);\n        return valueNode;\n    }\n    var visitor = {\n        onObjectBegin: function (offset) {\n            currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });\n        },\n        onObjectProperty: function (name, offset, length) {\n            currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });\n            currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });\n        },\n        onObjectEnd: function (offset, length) {\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onArrayBegin: function (offset, length) {\n            currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });\n        },\n        onArrayEnd: function (offset, length) {\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onLiteralValue: function (value, offset, length) {\n            onValue({ type: getLiteralNodeType(value), offset: offset, length: length, parent: currentParent, value: value });\n            ensurePropertyComplete(offset + length);\n        },\n        onSeparator: function (sep, offset, length) {\n            if (currentParent.type === 'property') {\n                if (sep === ':') {\n                    currentParent.colonOffset = offset;\n                }\n                else if (sep === ',') {\n                    ensurePropertyComplete(offset);\n                }\n            }\n        },\n        onError: function (error, offset, length) {\n            errors.push({ error: error, offset: offset, length: length });\n        }\n    };\n    visit(text, visitor, options);\n    var result = currentParent.children[0];\n    if (result) {\n        delete result.parent;\n    }\n    return result;\n}\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport function findNodeAtLocation(root, path) {\n    if (!root) {\n        return void 0;\n    }\n    var node = root;\n    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {\n        var segment = path_1[_i];\n        if (typeof segment === 'string') {\n            if (node.type !== 'object' || !Array.isArray(node.children)) {\n                return void 0;\n            }\n            var found = false;\n            for (var _a = 0, _b = node.children; _a < _b.length; _a++) {\n                var propertyNode = _b[_a];\n                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {\n                    node = propertyNode.children[1];\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) {\n                return void 0;\n            }\n        }\n        else {\n            var index = segment;\n            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {\n                return void 0;\n            }\n            node = node.children[index];\n        }\n    }\n    return node;\n}\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport function getNodePath(node) {\n    if (!node.parent || !node.parent.children) {\n        return [];\n    }\n    var path = getNodePath(node.parent);\n    if (node.parent.type === 'property') {\n        var key = node.parent.children[0].value;\n        path.push(key);\n    }\n    else if (node.parent.type === 'array') {\n        var index = node.parent.children.indexOf(node);\n        if (index !== -1) {\n            path.push(index);\n        }\n    }\n    return path;\n}\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport function getNodeValue(node) {\n    switch (node.type) {\n        case 'array':\n            return node.children.map(getNodeValue);\n        case 'object':\n            var obj = Object.create(null);\n            for (var _i = 0, _a = node.children; _i < _a.length; _i++) {\n                var prop = _a[_i];\n                var valueNode = prop.children[1];\n                if (valueNode) {\n                    obj[prop.children[0].value] = getNodeValue(valueNode);\n                }\n            }\n            return obj;\n        case 'null':\n        case 'string':\n        case 'number':\n        case 'boolean':\n            return node.value;\n        default:\n            return void 0;\n    }\n}\nexport function contains(node, offset, includeRightBound) {\n    if (includeRightBound === void 0) { includeRightBound = false; }\n    return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));\n}\n/**\n * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport function findNodeAtOffset(node, offset, includeRightBound) {\n    if (includeRightBound === void 0) { includeRightBound = false; }\n    if (contains(node, offset, includeRightBound)) {\n        var children = node.children;\n        if (Array.isArray(children)) {\n            for (var i = 0; i < children.length && children[i].offset <= offset; i++) {\n                var item = findNodeAtOffset(children[i], offset, includeRightBound);\n                if (item) {\n                    return item;\n                }\n            }\n        }\n        return node;\n    }\n    return void 0;\n}\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport function visit(text, visitor, options) {\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var _scanner = createScanner(text, false);\n    function toNoArgVisit(visitFunction) {\n        return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };\n    }\n    function toOneArgVisit(visitFunction) {\n        return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };\n    }\n    var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);\n    var disallowComments = options && options.disallowComments;\n    var allowTrailingComma = options && options.allowTrailingComma;\n    function scanNext() {\n        while (true) {\n            var token = _scanner.scan();\n            switch (_scanner.getTokenError()) {\n                case 4 /* InvalidUnicode */:\n                    handleError(14 /* InvalidUnicode */);\n                    break;\n                case 5 /* InvalidEscapeCharacter */:\n                    handleError(15 /* InvalidEscapeCharacter */);\n                    break;\n                case 3 /* UnexpectedEndOfNumber */:\n                    handleError(13 /* UnexpectedEndOfNumber */);\n                    break;\n                case 1 /* UnexpectedEndOfComment */:\n                    if (!disallowComments) {\n                        handleError(11 /* UnexpectedEndOfComment */);\n                    }\n                    break;\n                case 2 /* UnexpectedEndOfString */:\n                    handleError(12 /* UnexpectedEndOfString */);\n                    break;\n                case 6 /* InvalidCharacter */:\n                    handleError(16 /* InvalidCharacter */);\n                    break;\n            }\n            switch (token) {\n                case 12 /* LineCommentTrivia */:\n                case 13 /* BlockCommentTrivia */:\n                    if (disallowComments) {\n                        handleError(10 /* InvalidCommentToken */);\n                    }\n                    else {\n                        onComment();\n                    }\n                    break;\n                case 16 /* Unknown */:\n                    handleError(1 /* InvalidSymbol */);\n                    break;\n                case 15 /* Trivia */:\n                case 14 /* LineBreakTrivia */:\n                    break;\n                default:\n                    return token;\n            }\n        }\n    }\n    function handleError(error, skipUntilAfter, skipUntil) {\n        if (skipUntilAfter === void 0) { skipUntilAfter = []; }\n        if (skipUntil === void 0) { skipUntil = []; }\n        onError(error);\n        if (skipUntilAfter.length + skipUntil.length > 0) {\n            var token = _scanner.getToken();\n            while (token !== 17 /* EOF */) {\n                if (skipUntilAfter.indexOf(token) !== -1) {\n                    scanNext();\n                    break;\n                }\n                else if (skipUntil.indexOf(token) !== -1) {\n                    break;\n                }\n                token = scanNext();\n            }\n        }\n    }\n    function parseString(isValue) {\n        var value = _scanner.getTokenValue();\n        if (isValue) {\n            onLiteralValue(value);\n        }\n        else {\n            onObjectProperty(value);\n        }\n        scanNext();\n        return true;\n    }\n    function parseLiteral() {\n        switch (_scanner.getToken()) {\n            case 11 /* NumericLiteral */:\n                var value = 0;\n                try {\n                    value = JSON.parse(_scanner.getTokenValue());\n                    if (typeof value !== 'number') {\n                        handleError(2 /* InvalidNumberFormat */);\n                        value = 0;\n                    }\n                }\n                catch (e) {\n                    handleError(2 /* InvalidNumberFormat */);\n                }\n                onLiteralValue(value);\n                break;\n            case 7 /* NullKeyword */:\n                onLiteralValue(null);\n                break;\n            case 8 /* TrueKeyword */:\n                onLiteralValue(true);\n                break;\n            case 9 /* FalseKeyword */:\n                onLiteralValue(false);\n                break;\n            default:\n                return false;\n        }\n        scanNext();\n        return true;\n    }\n    function parseProperty() {\n        if (_scanner.getToken() !== 10 /* StringLiteral */) {\n            handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            return false;\n        }\n        parseString(false);\n        if (_scanner.getToken() === 6 /* ColonToken */) {\n            onSeparator(':');\n            scanNext(); // consume colon\n            if (!parseValue()) {\n                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            }\n        }\n        else {\n            handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n        }\n        return true;\n    }\n    function parseObject() {\n        onObjectBegin();\n        scanNext(); // consume open brace\n        var needsComma = false;\n        while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {\n            if (_scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* CommaExpected */, [], []);\n            }\n            if (!parseProperty()) {\n                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onObjectEnd();\n        if (_scanner.getToken() !== 2 /* CloseBraceToken */) {\n            handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);\n        }\n        else {\n            scanNext(); // consume close brace\n        }\n        return true;\n    }\n    function parseArray() {\n        onArrayBegin();\n        scanNext(); // consume open bracket\n        var needsComma = false;\n        while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {\n            if (_scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* CommaExpected */, [], []);\n            }\n            if (!parseValue()) {\n                handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onArrayEnd();\n        if (_scanner.getToken() !== 4 /* CloseBracketToken */) {\n            handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);\n        }\n        else {\n            scanNext(); // consume close bracket\n        }\n        return true;\n    }\n    function parseValue() {\n        switch (_scanner.getToken()) {\n            case 3 /* OpenBracketToken */:\n                return parseArray();\n            case 1 /* OpenBraceToken */:\n                return parseObject();\n            case 10 /* StringLiteral */:\n                return parseString(true);\n            default:\n                return parseLiteral();\n        }\n    }\n    scanNext();\n    if (_scanner.getToken() === 17 /* EOF */) {\n        return true;\n    }\n    if (!parseValue()) {\n        handleError(4 /* ValueExpected */, [], []);\n        return false;\n    }\n    if (_scanner.getToken() !== 17 /* EOF */) {\n        handleError(9 /* EndOfFileExpected */, [], []);\n    }\n    return true;\n}\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport function stripComments(text, replaceCh) {\n    var _scanner = createScanner(text), parts = [], kind, offset = 0, pos;\n    do {\n        pos = _scanner.getPosition();\n        kind = _scanner.scan();\n        switch (kind) {\n            case 12 /* LineCommentTrivia */:\n            case 13 /* BlockCommentTrivia */:\n            case 17 /* EOF */:\n                if (offset !== pos) {\n                    parts.push(text.substring(offset, pos));\n                }\n                if (replaceCh !== void 0) {\n                    parts.push(_scanner.getTokenValue().replace(/[^\\r\\n]/g, replaceCh));\n                }\n                offset = _scanner.getPosition();\n                break;\n        }\n    } while (kind !== 17 /* EOF */);\n    return parts.join('');\n}\nfunction getLiteralNodeType(value) {\n    switch (typeof value) {\n        case 'boolean': return 'boolean';\n        case 'number': return 'number';\n        case 'string': return 'string';\n        default: return 'null';\n    }\n}\n//# sourceMappingURL=parser.js.map","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport function createScanner(text, ignoreTrivia) {\n    if (ignoreTrivia === void 0) { ignoreTrivia = false; }\n    var pos = 0, len = text.length, value = '', tokenOffset = 0, token = 16 /* Unknown */, scanError = 0 /* None */;\n    function scanHexDigits(count, exact) {\n        var digits = 0;\n        var value = 0;\n        while (digits < count || !exact) {\n            var ch = text.charCodeAt(pos);\n            if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {\n                value = value * 16 + ch - 48 /* _0 */;\n            }\n            else if (ch >= 65 /* A */ && ch <= 70 /* F */) {\n                value = value * 16 + ch - 65 /* A */ + 10;\n            }\n            else if (ch >= 97 /* a */ && ch <= 102 /* f */) {\n                value = value * 16 + ch - 97 /* a */ + 10;\n            }\n            else {\n                break;\n            }\n            pos++;\n            digits++;\n        }\n        if (digits < count) {\n            value = -1;\n        }\n        return value;\n    }\n    function setPosition(newPosition) {\n        pos = newPosition;\n        value = '';\n        tokenOffset = 0;\n        token = 16 /* Unknown */;\n        scanError = 0 /* None */;\n    }\n    function scanNumber() {\n        var start = pos;\n        if (text.charCodeAt(pos) === 48 /* _0 */) {\n            pos++;\n        }\n        else {\n            pos++;\n            while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n            }\n        }\n        if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {\n            pos++;\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n            }\n            else {\n                scanError = 3 /* UnexpectedEndOfNumber */;\n                return text.substring(start, pos);\n            }\n        }\n        var end = pos;\n        if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {\n            pos++;\n            if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {\n                pos++;\n            }\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n                end = pos;\n            }\n            else {\n                scanError = 3 /* UnexpectedEndOfNumber */;\n            }\n        }\n        return text.substring(start, end);\n    }\n    function scanString() {\n        var result = '', start = pos;\n        while (true) {\n            if (pos >= len) {\n                result += text.substring(start, pos);\n                scanError = 2 /* UnexpectedEndOfString */;\n                break;\n            }\n            var ch = text.charCodeAt(pos);\n            if (ch === 34 /* doubleQuote */) {\n                result += text.substring(start, pos);\n                pos++;\n                break;\n            }\n            if (ch === 92 /* backslash */) {\n                result += text.substring(start, pos);\n                pos++;\n                if (pos >= len) {\n                    scanError = 2 /* UnexpectedEndOfString */;\n                    break;\n                }\n                ch = text.charCodeAt(pos++);\n                switch (ch) {\n                    case 34 /* doubleQuote */:\n                        result += '\\\"';\n                        break;\n                    case 92 /* backslash */:\n                        result += '\\\\';\n                        break;\n                    case 47 /* slash */:\n                        result += '/';\n                        break;\n                    case 98 /* b */:\n                        result += '\\b';\n                        break;\n                    case 102 /* f */:\n                        result += '\\f';\n                        break;\n                    case 110 /* n */:\n                        result += '\\n';\n                        break;\n                    case 114 /* r */:\n                        result += '\\r';\n                        break;\n                    case 116 /* t */:\n                        result += '\\t';\n                        break;\n                    case 117 /* u */:\n                        var ch_1 = scanHexDigits(4, true);\n                        if (ch_1 >= 0) {\n                            result += String.fromCharCode(ch_1);\n                        }\n                        else {\n                            scanError = 4 /* InvalidUnicode */;\n                        }\n                        break;\n                    default:\n                        scanError = 5 /* InvalidEscapeCharacter */;\n                }\n                start = pos;\n                continue;\n            }\n            if (ch >= 0 && ch <= 0x1f) {\n                if (isLineBreak(ch)) {\n                    result += text.substring(start, pos);\n                    scanError = 2 /* UnexpectedEndOfString */;\n                    break;\n                }\n                else {\n                    scanError = 6 /* InvalidCharacter */;\n                    // mark as error but continue with string\n                }\n            }\n            pos++;\n        }\n        return result;\n    }\n    function scanNext() {\n        value = '';\n        scanError = 0 /* None */;\n        tokenOffset = pos;\n        if (pos >= len) {\n            // at the end\n            tokenOffset = len;\n            return token = 17 /* EOF */;\n        }\n        var code = text.charCodeAt(pos);\n        // trivia: whitespace\n        if (isWhiteSpace(code)) {\n            do {\n                pos++;\n                value += String.fromCharCode(code);\n                code = text.charCodeAt(pos);\n            } while (isWhiteSpace(code));\n            return token = 15 /* Trivia */;\n        }\n        // trivia: newlines\n        if (isLineBreak(code)) {\n            pos++;\n            value += String.fromCharCode(code);\n            if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {\n                pos++;\n                value += '\\n';\n            }\n            return token = 14 /* LineBreakTrivia */;\n        }\n        switch (code) {\n            // tokens: []{}:,\n            case 123 /* openBrace */:\n                pos++;\n                return token = 1 /* OpenBraceToken */;\n            case 125 /* closeBrace */:\n                pos++;\n                return token = 2 /* CloseBraceToken */;\n            case 91 /* openBracket */:\n                pos++;\n                return token = 3 /* OpenBracketToken */;\n            case 93 /* closeBracket */:\n                pos++;\n                return token = 4 /* CloseBracketToken */;\n            case 58 /* colon */:\n                pos++;\n                return token = 6 /* ColonToken */;\n            case 44 /* comma */:\n                pos++;\n                return token = 5 /* CommaToken */;\n            // strings\n            case 34 /* doubleQuote */:\n                pos++;\n                value = scanString();\n                return token = 10 /* StringLiteral */;\n            // comments\n            case 47 /* slash */:\n                var start = pos - 1;\n                // Single-line comment\n                if (text.charCodeAt(pos + 1) === 47 /* slash */) {\n                    pos += 2;\n                    while (pos < len) {\n                        if (isLineBreak(text.charCodeAt(pos))) {\n                            break;\n                        }\n                        pos++;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 12 /* LineCommentTrivia */;\n                }\n                // Multi-line comment\n                if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {\n                    pos += 2;\n                    var safeLength = len - 1; // For lookahead.\n                    var commentClosed = false;\n                    while (pos < safeLength) {\n                        var ch = text.charCodeAt(pos);\n                        if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {\n                            pos += 2;\n                            commentClosed = true;\n                            break;\n                        }\n                        pos++;\n                    }\n                    if (!commentClosed) {\n                        pos++;\n                        scanError = 1 /* UnexpectedEndOfComment */;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 13 /* BlockCommentTrivia */;\n                }\n                // just a single slash\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* Unknown */;\n            // numbers\n            case 45 /* minus */:\n                value += String.fromCharCode(code);\n                pos++;\n                if (pos === len || !isDigit(text.charCodeAt(pos))) {\n                    return token = 16 /* Unknown */;\n                }\n            // found a minus, followed by a number so\n            // we fall through to proceed with scanning\n            // numbers\n            case 48 /* _0 */:\n            case 49 /* _1 */:\n            case 50 /* _2 */:\n            case 51 /* _3 */:\n            case 52 /* _4 */:\n            case 53 /* _5 */:\n            case 54 /* _6 */:\n            case 55 /* _7 */:\n            case 56 /* _8 */:\n            case 57 /* _9 */:\n                value += scanNumber();\n                return token = 11 /* NumericLiteral */;\n            // literals and unknown symbols\n            default:\n                // is a literal? Read the full word.\n                while (pos < len && isUnknownContentCharacter(code)) {\n                    pos++;\n                    code = text.charCodeAt(pos);\n                }\n                if (tokenOffset !== pos) {\n                    value = text.substring(tokenOffset, pos);\n                    // keywords: true, false, null\n                    switch (value) {\n                        case 'true': return token = 8 /* TrueKeyword */;\n                        case 'false': return token = 9 /* FalseKeyword */;\n                        case 'null': return token = 7 /* NullKeyword */;\n                    }\n                    return token = 16 /* Unknown */;\n                }\n                // some\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* Unknown */;\n        }\n    }\n    function isUnknownContentCharacter(code) {\n        if (isWhiteSpace(code) || isLineBreak(code)) {\n            return false;\n        }\n        switch (code) {\n            case 125 /* closeBrace */:\n            case 93 /* closeBracket */:\n            case 123 /* openBrace */:\n            case 91 /* openBracket */:\n            case 34 /* doubleQuote */:\n            case 58 /* colon */:\n            case 44 /* comma */:\n            case 47 /* slash */:\n                return false;\n        }\n        return true;\n    }\n    function scanNextNonTrivia() {\n        var result;\n        do {\n            result = scanNext();\n        } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);\n        return result;\n    }\n    return {\n        setPosition: setPosition,\n        getPosition: function () { return pos; },\n        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,\n        getToken: function () { return token; },\n        getTokenValue: function () { return value; },\n        getTokenOffset: function () { return tokenOffset; },\n        getTokenLength: function () { return pos - tokenOffset; },\n        getTokenError: function () { return scanError; }\n    };\n}\nfunction isWhiteSpace(ch) {\n    return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||\n        ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||\n        ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;\n}\nfunction isLineBreak(ch) {\n    return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;\n}\nfunction isDigit(ch) {\n    return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;\n}\n//# sourceMappingURL=scanner.js.map","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport { createScanner } from './scanner.js';\nexport function format(documentText, range, options) {\n    var initialIndentLevel;\n    var formatText;\n    var formatTextStart;\n    var rangeStart;\n    var rangeEnd;\n    if (range) {\n        rangeStart = range.offset;\n        rangeEnd = rangeStart + range.length;\n        formatTextStart = rangeStart;\n        while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {\n            formatTextStart--;\n        }\n        var endOffset = rangeEnd;\n        while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {\n            endOffset++;\n        }\n        formatText = documentText.substring(formatTextStart, endOffset);\n        initialIndentLevel = computeIndentLevel(formatText, options);\n    }\n    else {\n        formatText = documentText;\n        initialIndentLevel = 0;\n        formatTextStart = 0;\n        rangeStart = 0;\n        rangeEnd = documentText.length;\n    }\n    var eol = getEOL(options, documentText);\n    var lineBreak = false;\n    var indentLevel = 0;\n    var indentValue;\n    if (options.insertSpaces) {\n        indentValue = repeat(' ', options.tabSize || 4);\n    }\n    else {\n        indentValue = '\\t';\n    }\n    var scanner = createScanner(formatText, false);\n    var hasError = false;\n    function newLineAndIndent() {\n        return eol + repeat(indentValue, initialIndentLevel + indentLevel);\n    }\n    function scanNext() {\n        var token = scanner.scan();\n        lineBreak = false;\n        while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {\n            lineBreak = lineBreak || (token === 14 /* LineBreakTrivia */);\n            token = scanner.scan();\n        }\n        hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;\n        return token;\n    }\n    var editOperations = [];\n    function addEdit(text, startOffset, endOffset) {\n        if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {\n            editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });\n        }\n    }\n    var firstToken = scanNext();\n    if (firstToken !== 17 /* EOF */) {\n        var firstTokenStart = scanner.getTokenOffset() + formatTextStart;\n        var initialIndent = repeat(indentValue, initialIndentLevel);\n        addEdit(initialIndent, formatTextStart, firstTokenStart);\n    }\n    while (firstToken !== 17 /* EOF */) {\n        var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;\n        var secondToken = scanNext();\n        var replaceContent = '';\n        while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {\n            // comments on the same line: keep them on the same line, but ignore them otherwise\n            var commentTokenStart = scanner.getTokenOffset() + formatTextStart;\n            addEdit(' ', firstTokenEnd, commentTokenStart);\n            firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;\n            replaceContent = secondToken === 12 /* LineCommentTrivia */ ? newLineAndIndent() : '';\n            secondToken = scanNext();\n        }\n        if (secondToken === 2 /* CloseBraceToken */) {\n            if (firstToken !== 1 /* OpenBraceToken */) {\n                indentLevel--;\n                replaceContent = newLineAndIndent();\n            }\n        }\n        else if (secondToken === 4 /* CloseBracketToken */) {\n            if (firstToken !== 3 /* OpenBracketToken */) {\n                indentLevel--;\n                replaceContent = newLineAndIndent();\n            }\n        }\n        else {\n            switch (firstToken) {\n                case 3 /* OpenBracketToken */:\n                case 1 /* OpenBraceToken */:\n                    indentLevel++;\n                    replaceContent = newLineAndIndent();\n                    break;\n                case 5 /* CommaToken */:\n                case 12 /* LineCommentTrivia */:\n                    replaceContent = newLineAndIndent();\n                    break;\n                case 13 /* BlockCommentTrivia */:\n                    if (lineBreak) {\n                        replaceContent = newLineAndIndent();\n                    }\n                    else {\n                        // symbol following comment on the same line: keep on same line, separate with ' '\n                        replaceContent = ' ';\n                    }\n                    break;\n                case 6 /* ColonToken */:\n                    replaceContent = ' ';\n                    break;\n                case 10 /* StringLiteral */:\n                    if (secondToken === 6 /* ColonToken */) {\n                        replaceContent = '';\n                        break;\n                    }\n                // fall through\n                case 7 /* NullKeyword */:\n                case 8 /* TrueKeyword */:\n                case 9 /* FalseKeyword */:\n                case 11 /* NumericLiteral */:\n                case 2 /* CloseBraceToken */:\n                case 4 /* CloseBracketToken */:\n                    if (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */) {\n                        replaceContent = ' ';\n                    }\n                    else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {\n                        hasError = true;\n                    }\n                    break;\n                case 16 /* Unknown */:\n                    hasError = true;\n                    break;\n            }\n            if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {\n                replaceContent = newLineAndIndent();\n            }\n        }\n        var secondTokenStart = scanner.getTokenOffset() + formatTextStart;\n        addEdit(replaceContent, firstTokenEnd, secondTokenStart);\n        firstToken = secondToken;\n    }\n    return editOperations;\n}\nfunction repeat(s, count) {\n    var result = '';\n    for (var i = 0; i < count; i++) {\n        result += s;\n    }\n    return result;\n}\nfunction computeIndentLevel(content, options) {\n    var i = 0;\n    var nChars = 0;\n    var tabSize = options.tabSize || 4;\n    while (i < content.length) {\n        var ch = content.charAt(i);\n        if (ch === ' ') {\n            nChars++;\n        }\n        else if (ch === '\\t') {\n            nChars += tabSize;\n        }\n        else {\n            break;\n        }\n        i++;\n    }\n    return Math.floor(nChars / tabSize);\n}\nfunction getEOL(options, text) {\n    for (var i = 0; i < text.length; i++) {\n        var ch = text.charAt(i);\n        if (ch === '\\r') {\n            if (i + 1 < text.length && text.charAt(i + 1) === '\\n') {\n                return '\\r\\n';\n            }\n            return '\\r';\n        }\n        else if (ch === '\\n') {\n            return '\\n';\n        }\n    }\n    return (options && options.eol) || '\\n';\n}\nexport function isEOL(text, offset) {\n    return '\\r\\n'.indexOf(text.charAt(offset)) !== -1;\n}\n//# sourceMappingURL=format.js.map","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as formatter from './impl/format.js';\nimport * as edit from './impl/edit.js';\nimport * as scanner from './impl/scanner.js';\nimport * as parser from './impl/parser.js';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport var createScanner = scanner.createScanner;\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport var getLocation = parser.getLocation;\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore always check the errors list to find out if the input was valid.\n */\nexport var parse = parser.parse;\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport var parseTree = parser.parseTree;\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport var findNodeAtLocation = parser.findNodeAtLocation;\n/**\n * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport var findNodeAtOffset = parser.findNodeAtOffset;\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport var getNodePath = parser.getNodePath;\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport var getNodeValue = parser.getNodeValue;\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport var visit = parser.visit;\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport var stripComments = parser.stripComments;\nexport function printParseErrorCode(code) {\n    switch (code) {\n        case 1 /* InvalidSymbol */: return 'InvalidSymbol';\n        case 2 /* InvalidNumberFormat */: return 'InvalidNumberFormat';\n        case 3 /* PropertyNameExpected */: return 'PropertyNameExpected';\n        case 4 /* ValueExpected */: return 'ValueExpected';\n        case 5 /* ColonExpected */: return 'ColonExpected';\n        case 6 /* CommaExpected */: return 'CommaExpected';\n        case 7 /* CloseBraceExpected */: return 'CloseBraceExpected';\n        case 8 /* CloseBracketExpected */: return 'CloseBracketExpected';\n        case 9 /* EndOfFileExpected */: return 'EndOfFileExpected';\n        case 10 /* InvalidCommentToken */: return 'InvalidCommentToken';\n        case 11 /* UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';\n        case 12 /* UnexpectedEndOfString */: return 'UnexpectedEndOfString';\n        case 13 /* UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';\n        case 14 /* InvalidUnicode */: return 'InvalidUnicode';\n        case 15 /* InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';\n        case 16 /* InvalidCharacter */: return 'InvalidCharacter';\n    }\n    return '<unknown ParseErrorCode>';\n}\n/**\n * Computes the edits needed to format a JSON document.\n *\n * @param documentText The input text\n * @param range The range to format or `undefined` to format the full content\n * @param options The formatting options\n * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or\n * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of\n * text in the original document. However, multiple edits can have\n * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.\n * To apply edits to an input, you can use `applyEdits`\n */\nexport function format(documentText, range, options) {\n    return formatter.format(documentText, range, options);\n}\n/**\n * Computes the edits needed to modify a value in the JSON document.\n *\n * @param documentText The input text\n * @param path The path of the value to change. The path represents either to the document root, a property or an array item.\n * If the path points to an non-existing property or item, it will be created.\n * @param value The new value for the specified property or item. If the value is undefined,\n * the property or item will be removed.\n * @param options Options\n * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or\n * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of\n * text in the original document. However, multiple edits can have\n * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.\n * To apply edits to an input, you can use `applyEdits`\n */\nexport function modify(text, path, value, options) {\n    return edit.setProperty(text, path, value, options.formattingOptions, options.getInsertionIndex);\n}\n/**\n * Applies edits to a input string.\n */\nexport function applyEdits(text, edits) {\n    for (var i = edits.length - 1; i >= 0; i--) {\n        text = edit.applyEdit(text, edits[i]);\n    }\n    return text;\n}\n//# sourceMappingURL=main.js.map","import { Range, TextEdit, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, MarkupKind } from '../vscode-languageserver-types/main.js';\nexport { Range, TextEdit, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind };\n// #region Proposed types, remove once added to vscode-languageserver-types\n/**\n * Enum of known selection range kinds\n */\nexport var SelectionRangeKind;\n(function (SelectionRangeKind) {\n    /**\n     * Empty Kind.\n     */\n    SelectionRangeKind[\"Empty\"] = \"\";\n    /**\n     * The statment kind, its value is `statement`, possible extensions can be\n     * `statement.if` etc\n     */\n    SelectionRangeKind[\"Statement\"] = \"statement\";\n    /**\n     * The declaration kind, its value is `declaration`, possible extensions can be\n     * `declaration.function`, `declaration.class` etc.\n     */\n    SelectionRangeKind[\"Declaration\"] = \"declaration\";\n})(SelectionRangeKind || (SelectionRangeKind = {}));\n// #endregion\n/**\n * Error codes used by diagnostics\n */\nexport var ErrorCode;\n(function (ErrorCode) {\n    ErrorCode[ErrorCode[\"Undefined\"] = 0] = \"Undefined\";\n    ErrorCode[ErrorCode[\"EnumValueMismatch\"] = 1] = \"EnumValueMismatch\";\n    ErrorCode[ErrorCode[\"UnexpectedEndOfComment\"] = 257] = \"UnexpectedEndOfComment\";\n    ErrorCode[ErrorCode[\"UnexpectedEndOfString\"] = 258] = \"UnexpectedEndOfString\";\n    ErrorCode[ErrorCode[\"UnexpectedEndOfNumber\"] = 259] = \"UnexpectedEndOfNumber\";\n    ErrorCode[ErrorCode[\"InvalidUnicode\"] = 260] = \"InvalidUnicode\";\n    ErrorCode[ErrorCode[\"InvalidEscapeCharacter\"] = 261] = \"InvalidEscapeCharacter\";\n    ErrorCode[ErrorCode[\"InvalidCharacter\"] = 262] = \"InvalidCharacter\";\n    ErrorCode[ErrorCode[\"PropertyExpected\"] = 513] = \"PropertyExpected\";\n    ErrorCode[ErrorCode[\"CommaExpected\"] = 514] = \"CommaExpected\";\n    ErrorCode[ErrorCode[\"ColonExpected\"] = 515] = \"ColonExpected\";\n    ErrorCode[ErrorCode[\"ValueExpected\"] = 516] = \"ValueExpected\";\n    ErrorCode[ErrorCode[\"CommaOrCloseBacketExpected\"] = 517] = \"CommaOrCloseBacketExpected\";\n    ErrorCode[ErrorCode[\"CommaOrCloseBraceExpected\"] = 518] = \"CommaOrCloseBraceExpected\";\n    ErrorCode[ErrorCode[\"TrailingComma\"] = 519] = \"TrailingComma\";\n    ErrorCode[ErrorCode[\"DuplicateKey\"] = 520] = \"DuplicateKey\";\n    ErrorCode[ErrorCode[\"CommentNotPermitted\"] = 521] = \"CommentNotPermitted\";\n    ErrorCode[ErrorCode[\"SchemaResolveError\"] = 768] = \"SchemaResolveError\";\n})(ErrorCode || (ErrorCode = {}));\nexport var ClientCapabilities;\n(function (ClientCapabilities) {\n    ClientCapabilities.LATEST = {\n        textDocument: {\n            completion: {\n                completionItem: {\n                    documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText]\n                }\n            }\n        }\n    };\n})(ClientCapabilities || (ClientCapabilities = {}));\n","/*---------------------------------------------------------------------------------------------\n*  Copyright (c) Microsoft Corporation. All rights reserved.\n*  Licensed under the MIT License. See License.txt in the project root for license information.\n*--------------------------------------------------------------------------------------------*/\nexport function equals(one, other) {\n    if (one === other) {\n        return true;\n    }\n    if (one === null || one === undefined || other === null || other === undefined) {\n        return false;\n    }\n    if (typeof one !== typeof other) {\n        return false;\n    }\n    if (typeof one !== 'object') {\n        return false;\n    }\n    if ((Array.isArray(one)) !== (Array.isArray(other))) {\n        return false;\n    }\n    var i, key;\n    if (Array.isArray(one)) {\n        if (one.length !== other.length) {\n            return false;\n        }\n        for (i = 0; i < one.length; i++) {\n            if (!equals(one[i], other[i])) {\n                return false;\n            }\n        }\n    }\n    else {\n        var oneKeys = [];\n        for (key in one) {\n            oneKeys.push(key);\n        }\n        oneKeys.sort();\n        var otherKeys = [];\n        for (key in other) {\n            otherKeys.push(key);\n        }\n        otherKeys.sort();\n        if (!equals(oneKeys, otherKeys)) {\n            return false;\n        }\n        for (i = 0; i < oneKeys.length; i++) {\n            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\nexport function isNumber(val) {\n    return typeof val === 'number';\n}\nexport function isDefined(val) {\n    return typeof val !== 'undefined';\n}\nexport function isBoolean(val) {\n    return typeof val === 'boolean';\n}\nexport function isString(val) {\n    return typeof val === 'string';\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nfunction format(message, args) {\n    var result;\n    if (args.length === 0) {\n        result = message;\n    }\n    else {\n        result = message.replace(/\\{(\\d+)\\}/g, function (match, rest) {\n            var index = rest[0];\n            return typeof args[index] !== 'undefined' ? args[index] : match;\n        });\n    }\n    return result;\n}\nfunction localize(key, message) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    return format(message, args);\n}\nexport function loadMessageBundle(file) {\n    return localize;\n}\nexport function config(opt) {\n    return loadMessageBundle;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    }\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport * as Json from '../../jsonc-parser/main.js';\nimport { isNumber, equals, isBoolean, isString, isDefined } from '../utils/objects.js';\nimport { ErrorCode } from '../jsonLanguageTypes.js';\nimport * as nls from '../../../fillers/vscode-nls.js';\nimport Uri from '../../vscode-uri/index.js';\nimport { Diagnostic, DiagnosticSeverity, Range } from '../../vscode-languageserver-types/main.js';\nvar localize = nls.loadMessageBundle();\nvar colorHexPattern = /^#([0-9A-Fa-f]{3,4}|([0-9A-Fa-f]{2}){3,4})$/;\nvar emailPattern = /^(([^<>()\\[\\]\\\\.,;:\\s@\"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@\"]+)*)|(\".+\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/;\nvar ASTNodeImpl = /** @class */ (function () {\n    function ASTNodeImpl(parent, offset, length) {\n        this.offset = offset;\n        this.length = length;\n        this.parent = parent;\n    }\n    Object.defineProperty(ASTNodeImpl.prototype, \"children\", {\n        get: function () {\n            return [];\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ASTNodeImpl.prototype.toString = function () {\n        return 'type: ' + this.type + ' (' + this.offset + '/' + this.length + ')' + (this.parent ? ' parent: {' + this.parent.toString() + '}' : '');\n    };\n    return ASTNodeImpl;\n}());\nexport { ASTNodeImpl };\nvar NullASTNodeImpl = /** @class */ (function (_super) {\n    __extends(NullASTNodeImpl, _super);\n    function NullASTNodeImpl(parent, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'null';\n        _this.value = null;\n        return _this;\n    }\n    return NullASTNodeImpl;\n}(ASTNodeImpl));\nexport { NullASTNodeImpl };\nvar BooleanASTNodeImpl = /** @class */ (function (_super) {\n    __extends(BooleanASTNodeImpl, _super);\n    function BooleanASTNodeImpl(parent, boolValue, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'boolean';\n        _this.value = boolValue;\n        return _this;\n    }\n    return BooleanASTNodeImpl;\n}(ASTNodeImpl));\nexport { BooleanASTNodeImpl };\nvar ArrayASTNodeImpl = /** @class */ (function (_super) {\n    __extends(ArrayASTNodeImpl, _super);\n    function ArrayASTNodeImpl(parent, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'array';\n        _this.items = [];\n        return _this;\n    }\n    Object.defineProperty(ArrayASTNodeImpl.prototype, \"children\", {\n        get: function () {\n            return this.items;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return ArrayASTNodeImpl;\n}(ASTNodeImpl));\nexport { ArrayASTNodeImpl };\nvar NumberASTNodeImpl = /** @class */ (function (_super) {\n    __extends(NumberASTNodeImpl, _super);\n    function NumberASTNodeImpl(parent, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'number';\n        _this.isInteger = true;\n        _this.value = Number.NaN;\n        return _this;\n    }\n    return NumberASTNodeImpl;\n}(ASTNodeImpl));\nexport { NumberASTNodeImpl };\nvar StringASTNodeImpl = /** @class */ (function (_super) {\n    __extends(StringASTNodeImpl, _super);\n    function StringASTNodeImpl(parent, offset, length) {\n        var _this = _super.call(this, parent, offset, length) || this;\n        _this.type = 'string';\n        _this.value = '';\n        return _this;\n    }\n    return StringASTNodeImpl;\n}(ASTNodeImpl));\nexport { StringASTNodeImpl };\nvar PropertyASTNodeImpl = /** @class */ (function (_super) {\n    __extends(PropertyASTNodeImpl, _super);\n    function PropertyASTNodeImpl(parent, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'property';\n        _this.colonOffset = -1;\n        return _this;\n    }\n    Object.defineProperty(PropertyASTNodeImpl.prototype, \"children\", {\n        get: function () {\n            return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return PropertyASTNodeImpl;\n}(ASTNodeImpl));\nexport { PropertyASTNodeImpl };\nvar ObjectASTNodeImpl = /** @class */ (function (_super) {\n    __extends(ObjectASTNodeImpl, _super);\n    function ObjectASTNodeImpl(parent, offset) {\n        var _this = _super.call(this, parent, offset) || this;\n        _this.type = 'object';\n        _this.properties = [];\n        return _this;\n    }\n    Object.defineProperty(ObjectASTNodeImpl.prototype, \"children\", {\n        get: function () {\n            return this.properties;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return ObjectASTNodeImpl;\n}(ASTNodeImpl));\nexport { ObjectASTNodeImpl };\nexport function asSchema(schema) {\n    if (isBoolean(schema)) {\n        return schema ? {} : { \"not\": {} };\n    }\n    return schema;\n}\nexport var EnumMatch;\n(function (EnumMatch) {\n    EnumMatch[EnumMatch[\"Key\"] = 0] = \"Key\";\n    EnumMatch[EnumMatch[\"Enum\"] = 1] = \"Enum\";\n})(EnumMatch || (EnumMatch = {}));\nvar SchemaCollector = /** @class */ (function () {\n    function SchemaCollector(focusOffset, exclude) {\n        if (focusOffset === void 0) { focusOffset = -1; }\n        if (exclude === void 0) { exclude = null; }\n        this.focusOffset = focusOffset;\n        this.exclude = exclude;\n        this.schemas = [];\n    }\n    SchemaCollector.prototype.add = function (schema) {\n        this.schemas.push(schema);\n    };\n    SchemaCollector.prototype.merge = function (other) {\n        var _a;\n        (_a = this.schemas).push.apply(_a, other.schemas);\n    };\n    SchemaCollector.prototype.include = function (node) {\n        return (this.focusOffset === -1 || contains(node, this.focusOffset)) && (node !== this.exclude);\n    };\n    SchemaCollector.prototype.newSub = function () {\n        return new SchemaCollector(-1, this.exclude);\n    };\n    return SchemaCollector;\n}());\nvar NoOpSchemaCollector = /** @class */ (function () {\n    function NoOpSchemaCollector() {\n    }\n    Object.defineProperty(NoOpSchemaCollector.prototype, \"schemas\", {\n        get: function () { return []; },\n        enumerable: true,\n        configurable: true\n    });\n    NoOpSchemaCollector.prototype.add = function (schema) { };\n    NoOpSchemaCollector.prototype.merge = function (other) { };\n    NoOpSchemaCollector.prototype.include = function (node) { return true; };\n    NoOpSchemaCollector.prototype.newSub = function () { return this; };\n    NoOpSchemaCollector.instance = new NoOpSchemaCollector();\n    return NoOpSchemaCollector;\n}());\nvar ValidationResult = /** @class */ (function () {\n    function ValidationResult() {\n        this.problems = [];\n        this.propertiesMatches = 0;\n        this.propertiesValueMatches = 0;\n        this.primaryValueMatches = 0;\n        this.enumValueMatch = false;\n        this.enumValues = null;\n    }\n    ValidationResult.prototype.hasProblems = function () {\n        return !!this.problems.length;\n    };\n    ValidationResult.prototype.mergeAll = function (validationResults) {\n        for (var _i = 0, validationResults_1 = validationResults; _i < validationResults_1.length; _i++) {\n            var validationResult = validationResults_1[_i];\n            this.merge(validationResult);\n        }\n    };\n    ValidationResult.prototype.merge = function (validationResult) {\n        this.problems = this.problems.concat(validationResult.problems);\n    };\n    ValidationResult.prototype.mergeEnumValues = function (validationResult) {\n        if (!this.enumValueMatch && !validationResult.enumValueMatch && this.enumValues && validationResult.enumValues) {\n            this.enumValues = this.enumValues.concat(validationResult.enumValues);\n            for (var _i = 0, _a = this.problems; _i < _a.length; _i++) {\n                var error = _a[_i];\n                if (error.code === ErrorCode.EnumValueMismatch) {\n                    error.message = localize('enumWarning', 'Value is not accepted. Valid values: {0}.', this.enumValues.map(function (v) { return JSON.stringify(v); }).join(', '));\n                }\n            }\n        }\n    };\n    ValidationResult.prototype.mergePropertyMatch = function (propertyValidationResult) {\n        this.merge(propertyValidationResult);\n        this.propertiesMatches++;\n        if (propertyValidationResult.enumValueMatch || !propertyValidationResult.hasProblems() && propertyValidationResult.propertiesMatches) {\n            this.propertiesValueMatches++;\n        }\n        if (propertyValidationResult.enumValueMatch && propertyValidationResult.enumValues && propertyValidationResult.enumValues.length === 1) {\n            this.primaryValueMatches++;\n        }\n    };\n    ValidationResult.prototype.compare = function (other) {\n        var hasProblems = this.hasProblems();\n        if (hasProblems !== other.hasProblems()) {\n            return hasProblems ? -1 : 1;\n        }\n        if (this.enumValueMatch !== other.enumValueMatch) {\n            return other.enumValueMatch ? -1 : 1;\n        }\n        if (this.primaryValueMatches !== other.primaryValueMatches) {\n            return this.primaryValueMatches - other.primaryValueMatches;\n        }\n        if (this.propertiesValueMatches !== other.propertiesValueMatches) {\n            return this.propertiesValueMatches - other.propertiesValueMatches;\n        }\n        return this.propertiesMatches - other.propertiesMatches;\n    };\n    return ValidationResult;\n}());\nexport { ValidationResult };\nexport function newJSONDocument(root, diagnostics) {\n    if (diagnostics === void 0) { diagnostics = []; }\n    return new JSONDocument(root, diagnostics, []);\n}\nexport function getNodeValue(node) {\n    return Json.getNodeValue(node);\n}\nexport function getNodePath(node) {\n    return Json.getNodePath(node);\n}\nexport function contains(node, offset, includeRightBound) {\n    if (includeRightBound === void 0) { includeRightBound = false; }\n    return offset >= node.offset && offset < (node.offset + node.length) || includeRightBound && offset === (node.offset + node.length);\n}\nvar JSONDocument = /** @class */ (function () {\n    function JSONDocument(root, syntaxErrors, comments) {\n        if (syntaxErrors === void 0) { syntaxErrors = []; }\n        if (comments === void 0) { comments = []; }\n        this.root = root;\n        this.syntaxErrors = syntaxErrors;\n        this.comments = comments;\n    }\n    JSONDocument.prototype.getNodeFromOffset = function (offset, includeRightBound) {\n        if (includeRightBound === void 0) { includeRightBound = false; }\n        if (this.root) {\n            return Json.findNodeAtOffset(this.root, offset, includeRightBound);\n        }\n        return void 0;\n    };\n    JSONDocument.prototype.visit = function (visitor) {\n        if (this.root) {\n            var doVisit_1 = function (node) {\n                var ctn = visitor(node);\n                var children = node.children;\n                if (Array.isArray(children)) {\n                    for (var i = 0; i < children.length && ctn; i++) {\n                        ctn = doVisit_1(children[i]);\n                    }\n                }\n                return ctn;\n            };\n            doVisit_1(this.root);\n        }\n    };\n    JSONDocument.prototype.validate = function (textDocument, schema) {\n        if (this.root && schema) {\n            var validationResult = new ValidationResult();\n            validate(this.root, schema, validationResult, NoOpSchemaCollector.instance);\n            return validationResult.problems.map(function (p) {\n                var range = Range.create(textDocument.positionAt(p.location.offset), textDocument.positionAt(p.location.offset + p.location.length));\n                return Diagnostic.create(range, p.message, p.severity, p.code);\n            });\n        }\n        return null;\n    };\n    JSONDocument.prototype.getMatchingSchemas = function (schema, focusOffset, exclude) {\n        if (focusOffset === void 0) { focusOffset = -1; }\n        if (exclude === void 0) { exclude = null; }\n        var matchingSchemas = new SchemaCollector(focusOffset, exclude);\n        if (this.root && schema) {\n            validate(this.root, schema, new ValidationResult(), matchingSchemas);\n        }\n        return matchingSchemas.schemas;\n    };\n    return JSONDocument;\n}());\nexport { JSONDocument };\nfunction validate(node, schema, validationResult, matchingSchemas) {\n    if (!node || !matchingSchemas.include(node)) {\n        return;\n    }\n    switch (node.type) {\n        case 'object':\n            _validateObjectNode(node, schema, validationResult, matchingSchemas);\n            break;\n        case 'array':\n            _validateArrayNode(node, schema, validationResult, matchingSchemas);\n            break;\n        case 'string':\n            _validateStringNode(node, schema, validationResult, matchingSchemas);\n            break;\n        case 'number':\n            _validateNumberNode(node, schema, validationResult, matchingSchemas);\n            break;\n        case 'property':\n            return validate(node.valueNode, schema, validationResult, matchingSchemas);\n    }\n    _validateNode();\n    matchingSchemas.add({ node: node, schema: schema });\n    function _validateNode() {\n        function matchesType(type) {\n            return node.type === type || (type === 'integer' && node.type === 'number' && node.isInteger);\n        }\n        if (Array.isArray(schema.type)) {\n            if (!schema.type.some(matchesType)) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: schema.errorMessage || localize('typeArrayMismatchWarning', 'Incorrect type. Expected one of {0}.', schema.type.join(', '))\n                });\n            }\n        }\n        else if (schema.type) {\n            if (!matchesType(schema.type)) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: schema.errorMessage || localize('typeMismatchWarning', 'Incorrect type. Expected \"{0}\".', schema.type)\n                });\n            }\n        }\n        if (Array.isArray(schema.allOf)) {\n            for (var _i = 0, _a = schema.allOf; _i < _a.length; _i++) {\n                var subSchemaRef = _a[_i];\n                validate(node, asSchema(subSchemaRef), validationResult, matchingSchemas);\n            }\n        }\n        var notSchema = asSchema(schema.not);\n        if (notSchema) {\n            var subValidationResult = new ValidationResult();\n            var subMatchingSchemas = matchingSchemas.newSub();\n            validate(node, notSchema, subValidationResult, subMatchingSchemas);\n            if (!subValidationResult.hasProblems()) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('notSchemaWarning', \"Matches a schema that is not allowed.\")\n                });\n            }\n            for (var _b = 0, _c = subMatchingSchemas.schemas; _b < _c.length; _b++) {\n                var ms = _c[_b];\n                ms.inverted = !ms.inverted;\n                matchingSchemas.add(ms);\n            }\n        }\n        var testAlternatives = function (alternatives, maxOneMatch) {\n            var matches = [];\n            // remember the best match that is used for error messages\n            var bestMatch = null;\n            for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) {\n                var subSchemaRef = alternatives_1[_i];\n                var subSchema = asSchema(subSchemaRef);\n                var subValidationResult = new ValidationResult();\n                var subMatchingSchemas = matchingSchemas.newSub();\n                validate(node, subSchema, subValidationResult, subMatchingSchemas);\n                if (!subValidationResult.hasProblems()) {\n                    matches.push(subSchema);\n                }\n                if (!bestMatch) {\n                    bestMatch = { schema: subSchema, validationResult: subValidationResult, matchingSchemas: subMatchingSchemas };\n                }\n                else {\n                    if (!maxOneMatch && !subValidationResult.hasProblems() && !bestMatch.validationResult.hasProblems()) {\n                        // no errors, both are equally good matches\n                        bestMatch.matchingSchemas.merge(subMatchingSchemas);\n                        bestMatch.validationResult.propertiesMatches += subValidationResult.propertiesMatches;\n                        bestMatch.validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;\n                    }\n                    else {\n                        var compareResult = subValidationResult.compare(bestMatch.validationResult);\n                        if (compareResult > 0) {\n                            // our node is the best matching so far\n                            bestMatch = { schema: subSchema, validationResult: subValidationResult, matchingSchemas: subMatchingSchemas };\n                        }\n                        else if (compareResult === 0) {\n                            // there's already a best matching but we are as good\n                            bestMatch.matchingSchemas.merge(subMatchingSchemas);\n                            bestMatch.validationResult.mergeEnumValues(subValidationResult);\n                        }\n                    }\n                }\n            }\n            if (matches.length > 1 && maxOneMatch) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: 1 },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('oneOfWarning', \"Matches multiple schemas when only one must validate.\")\n                });\n            }\n            if (bestMatch !== null) {\n                validationResult.merge(bestMatch.validationResult);\n                validationResult.propertiesMatches += bestMatch.validationResult.propertiesMatches;\n                validationResult.propertiesValueMatches += bestMatch.validationResult.propertiesValueMatches;\n                matchingSchemas.merge(bestMatch.matchingSchemas);\n            }\n            return matches.length;\n        };\n        if (Array.isArray(schema.anyOf)) {\n            testAlternatives(schema.anyOf, false);\n        }\n        if (Array.isArray(schema.oneOf)) {\n            testAlternatives(schema.oneOf, true);\n        }\n        var testBranch = function (schema) {\n            var subValidationResult = new ValidationResult();\n            var subMatchingSchemas = matchingSchemas.newSub();\n            validate(node, asSchema(schema), subValidationResult, subMatchingSchemas);\n            validationResult.merge(subValidationResult);\n            validationResult.propertiesMatches += subValidationResult.propertiesMatches;\n            validationResult.propertiesValueMatches += subValidationResult.propertiesValueMatches;\n            matchingSchemas.merge(subMatchingSchemas);\n        };\n        var testCondition = function (ifSchema, thenSchema, elseSchema) {\n            var subSchema = asSchema(ifSchema);\n            var subValidationResult = new ValidationResult();\n            var subMatchingSchemas = matchingSchemas.newSub();\n            validate(node, subSchema, subValidationResult, subMatchingSchemas);\n            matchingSchemas.merge(subMatchingSchemas);\n            if (!subValidationResult.hasProblems()) {\n                if (thenSchema) {\n                    testBranch(thenSchema);\n                }\n            }\n            else if (elseSchema) {\n                testBranch(elseSchema);\n            }\n        };\n        var ifSchema = asSchema(schema.if);\n        if (ifSchema) {\n            testCondition(ifSchema, asSchema(schema.then), asSchema(schema.else));\n        }\n        if (Array.isArray(schema.enum)) {\n            var val = getNodeValue(node);\n            var enumValueMatch = false;\n            for (var _d = 0, _e = schema.enum; _d < _e.length; _d++) {\n                var e = _e[_d];\n                if (equals(val, e)) {\n                    enumValueMatch = true;\n                    break;\n                }\n            }\n            validationResult.enumValues = schema.enum;\n            validationResult.enumValueMatch = enumValueMatch;\n            if (!enumValueMatch) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    code: ErrorCode.EnumValueMismatch,\n                    message: schema.errorMessage || localize('enumWarning', 'Value is not accepted. Valid values: {0}.', schema.enum.map(function (v) { return JSON.stringify(v); }).join(', '))\n                });\n            }\n        }\n        if (isDefined(schema.const)) {\n            var val = getNodeValue(node);\n            if (!equals(val, schema.const)) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    code: ErrorCode.EnumValueMismatch,\n                    message: schema.errorMessage || localize('constWarning', 'Value must be {0}.', JSON.stringify(schema.const))\n                });\n                validationResult.enumValueMatch = false;\n            }\n            else {\n                validationResult.enumValueMatch = true;\n            }\n            validationResult.enumValues = [schema.const];\n        }\n        if (schema.deprecationMessage && node.parent) {\n            validationResult.problems.push({\n                location: { offset: node.parent.offset, length: node.parent.length },\n                severity: DiagnosticSeverity.Warning,\n                message: schema.deprecationMessage\n            });\n        }\n    }\n    function _validateNumberNode(node, schema, validationResult, matchingSchemas) {\n        var val = node.value;\n        if (isNumber(schema.multipleOf)) {\n            if (val % schema.multipleOf !== 0) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('multipleOfWarning', 'Value is not divisible by {0}.', schema.multipleOf)\n                });\n            }\n        }\n        function getExclusiveLimit(limit, exclusive) {\n            if (isNumber(exclusive)) {\n                return exclusive;\n            }\n            if (isBoolean(exclusive) && exclusive) {\n                return limit;\n            }\n            return void 0;\n        }\n        function getLimit(limit, exclusive) {\n            if (!isBoolean(exclusive) || !exclusive) {\n                return limit;\n            }\n            return void 0;\n        }\n        var exclusiveMinimum = getExclusiveLimit(schema.minimum, schema.exclusiveMinimum);\n        if (isNumber(exclusiveMinimum) && val <= exclusiveMinimum) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('exclusiveMinimumWarning', 'Value is below the exclusive minimum of {0}.', exclusiveMinimum)\n            });\n        }\n        var exclusiveMaximum = getExclusiveLimit(schema.maximum, schema.exclusiveMaximum);\n        if (isNumber(exclusiveMaximum) && val >= exclusiveMaximum) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('exclusiveMaximumWarning', 'Value is above the exclusive maximum of {0}.', exclusiveMaximum)\n            });\n        }\n        var minimum = getLimit(schema.minimum, schema.exclusiveMinimum);\n        if (isNumber(minimum) && val < minimum) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('minimumWarning', 'Value is below the minimum of {0}.', minimum)\n            });\n        }\n        var maximum = getLimit(schema.maximum, schema.exclusiveMaximum);\n        if (isNumber(maximum) && val > maximum) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('maximumWarning', 'Value is above the maximum of {0}.', maximum)\n            });\n        }\n    }\n    function _validateStringNode(node, schema, validationResult, matchingSchemas) {\n        if (isNumber(schema.minLength) && node.value.length < schema.minLength) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('minLengthWarning', 'String is shorter than the minimum length of {0}.', schema.minLength)\n            });\n        }\n        if (isNumber(schema.maxLength) && node.value.length > schema.maxLength) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('maxLengthWarning', 'String is longer than the maximum length of {0}.', schema.maxLength)\n            });\n        }\n        if (isString(schema.pattern)) {\n            var regex = new RegExp(schema.pattern);\n            if (!regex.test(node.value)) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: schema.patternErrorMessage || schema.errorMessage || localize('patternWarning', 'String does not match the pattern of \"{0}\".', schema.pattern)\n                });\n            }\n        }\n        if (schema.format) {\n            switch (schema.format) {\n                case 'uri':\n                case 'uri-reference':\n                    {\n                        var errorMessage = void 0;\n                        if (!node.value) {\n                            errorMessage = localize('uriEmpty', 'URI expected.');\n                        }\n                        else {\n                            try {\n                                var uri = Uri.parse(node.value);\n                                if (!uri.scheme && schema.format === 'uri') {\n                                    errorMessage = localize('uriSchemeMissing', 'URI with a scheme is expected.');\n                                }\n                            }\n                            catch (e) {\n                                errorMessage = e.message;\n                            }\n                        }\n                        if (errorMessage) {\n                            validationResult.problems.push({\n                                location: { offset: node.offset, length: node.length },\n                                severity: DiagnosticSeverity.Warning,\n                                message: schema.patternErrorMessage || schema.errorMessage || localize('uriFormatWarning', 'String is not a URI: {0}', errorMessage)\n                            });\n                        }\n                    }\n                    break;\n                case 'email':\n                    {\n                        if (!node.value.match(emailPattern)) {\n                            validationResult.problems.push({\n                                location: { offset: node.offset, length: node.length },\n                                severity: DiagnosticSeverity.Warning,\n                                message: schema.patternErrorMessage || schema.errorMessage || localize('emailFormatWarning', 'String is not an e-mail address.')\n                            });\n                        }\n                    }\n                    break;\n                case 'color-hex':\n                    {\n                        if (!node.value.match(colorHexPattern)) {\n                            validationResult.problems.push({\n                                location: { offset: node.offset, length: node.length },\n                                severity: DiagnosticSeverity.Warning,\n                                message: schema.patternErrorMessage || schema.errorMessage || localize('colorHexFormatWarning', 'Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA.')\n                            });\n                        }\n                    }\n                    break;\n                default:\n            }\n        }\n    }\n    function _validateArrayNode(node, schema, validationResult, matchingSchemas) {\n        if (Array.isArray(schema.items)) {\n            var subSchemas = schema.items;\n            for (var index = 0; index < subSchemas.length; index++) {\n                var subSchemaRef = subSchemas[index];\n                var subSchema = asSchema(subSchemaRef);\n                var itemValidationResult = new ValidationResult();\n                var item = node.items[index];\n                if (item) {\n                    validate(item, subSchema, itemValidationResult, matchingSchemas);\n                    validationResult.mergePropertyMatch(itemValidationResult);\n                }\n                else if (node.items.length >= subSchemas.length) {\n                    validationResult.propertiesValueMatches++;\n                }\n            }\n            if (node.items.length > subSchemas.length) {\n                if (typeof schema.additionalItems === 'object') {\n                    for (var i = subSchemas.length; i < node.items.length; i++) {\n                        var itemValidationResult = new ValidationResult();\n                        validate(node.items[i], schema.additionalItems, itemValidationResult, matchingSchemas);\n                        validationResult.mergePropertyMatch(itemValidationResult);\n                    }\n                }\n                else if (schema.additionalItems === false) {\n                    validationResult.problems.push({\n                        location: { offset: node.offset, length: node.length },\n                        severity: DiagnosticSeverity.Warning,\n                        message: localize('additionalItemsWarning', 'Array has too many items according to schema. Expected {0} or fewer.', subSchemas.length)\n                    });\n                }\n            }\n        }\n        else {\n            var itemSchema = asSchema(schema.items);\n            if (itemSchema) {\n                for (var _i = 0, _a = node.items; _i < _a.length; _i++) {\n                    var item = _a[_i];\n                    var itemValidationResult = new ValidationResult();\n                    validate(item, itemSchema, itemValidationResult, matchingSchemas);\n                    validationResult.mergePropertyMatch(itemValidationResult);\n                }\n            }\n        }\n        var containsSchema = asSchema(schema.contains);\n        if (containsSchema) {\n            var doesContain = node.items.some(function (item) {\n                var itemValidationResult = new ValidationResult();\n                validate(item, containsSchema, itemValidationResult, NoOpSchemaCollector.instance);\n                return !itemValidationResult.hasProblems();\n            });\n            if (!doesContain) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: schema.errorMessage || localize('requiredItemMissingWarning', 'Array does not contain required item.')\n                });\n            }\n        }\n        if (isNumber(schema.minItems) && node.items.length < schema.minItems) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('minItemsWarning', 'Array has too few items. Expected {0} or more.', schema.minItems)\n            });\n        }\n        if (isNumber(schema.maxItems) && node.items.length > schema.maxItems) {\n            validationResult.problems.push({\n                location: { offset: node.offset, length: node.length },\n                severity: DiagnosticSeverity.Warning,\n                message: localize('maxItemsWarning', 'Array has too many items. Expected {0} or fewer.', schema.maxItems)\n            });\n        }\n        if (schema.uniqueItems === true) {\n            var values_1 = getNodeValue(node);\n            var duplicates = values_1.some(function (value, index) {\n                return index !== values_1.lastIndexOf(value);\n            });\n            if (duplicates) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('uniqueItemsWarning', 'Array has duplicate items.')\n                });\n            }\n        }\n    }\n    function _validateObjectNode(node, schema, validationResult, matchingSchemas) {\n        var seenKeys = Object.create(null);\n        var unprocessedProperties = [];\n        for (var _i = 0, _a = node.properties; _i < _a.length; _i++) {\n            var propertyNode = _a[_i];\n            var key = propertyNode.keyNode.value;\n            seenKeys[key] = propertyNode.valueNode;\n            unprocessedProperties.push(key);\n        }\n        if (Array.isArray(schema.required)) {\n            for (var _b = 0, _c = schema.required; _b < _c.length; _b++) {\n                var propertyName = _c[_b];\n                if (!seenKeys[propertyName]) {\n                    var keyNode = node.parent && node.parent.type === 'property' && node.parent.keyNode;\n                    var location = keyNode ? { offset: keyNode.offset, length: keyNode.length } : { offset: node.offset, length: 1 };\n                    validationResult.problems.push({\n                        location: location,\n                        severity: DiagnosticSeverity.Warning,\n                        message: localize('MissingRequiredPropWarning', 'Missing property \"{0}\".', propertyName)\n                    });\n                }\n            }\n        }\n        var propertyProcessed = function (prop) {\n            var index = unprocessedProperties.indexOf(prop);\n            while (index >= 0) {\n                unprocessedProperties.splice(index, 1);\n                index = unprocessedProperties.indexOf(prop);\n            }\n        };\n        if (schema.properties) {\n            for (var _d = 0, _e = Object.keys(schema.properties); _d < _e.length; _d++) {\n                var propertyName = _e[_d];\n                propertyProcessed(propertyName);\n                var propertySchema = schema.properties[propertyName];\n                var child = seenKeys[propertyName];\n                if (child) {\n                    if (isBoolean(propertySchema)) {\n                        if (!propertySchema) {\n                            var propertyNode = child.parent;\n                            validationResult.problems.push({\n                                location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },\n                                severity: DiagnosticSeverity.Warning,\n                                message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)\n                            });\n                        }\n                        else {\n                            validationResult.propertiesMatches++;\n                            validationResult.propertiesValueMatches++;\n                        }\n                    }\n                    else {\n                        var propertyValidationResult = new ValidationResult();\n                        validate(child, propertySchema, propertyValidationResult, matchingSchemas);\n                        validationResult.mergePropertyMatch(propertyValidationResult);\n                    }\n                }\n            }\n        }\n        if (schema.patternProperties) {\n            for (var _f = 0, _g = Object.keys(schema.patternProperties); _f < _g.length; _f++) {\n                var propertyPattern = _g[_f];\n                var regex = new RegExp(propertyPattern);\n                for (var _h = 0, _j = unprocessedProperties.slice(0); _h < _j.length; _h++) {\n                    var propertyName = _j[_h];\n                    if (regex.test(propertyName)) {\n                        propertyProcessed(propertyName);\n                        var child = seenKeys[propertyName];\n                        if (child) {\n                            var propertySchema = schema.patternProperties[propertyPattern];\n                            if (isBoolean(propertySchema)) {\n                                if (!propertySchema) {\n                                    var propertyNode = child.parent;\n                                    validationResult.problems.push({\n                                        location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },\n                                        severity: DiagnosticSeverity.Warning,\n                                        message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)\n                                    });\n                                }\n                                else {\n                                    validationResult.propertiesMatches++;\n                                    validationResult.propertiesValueMatches++;\n                                }\n                            }\n                            else {\n                                var propertyValidationResult = new ValidationResult();\n                                validate(child, propertySchema, propertyValidationResult, matchingSchemas);\n                                validationResult.mergePropertyMatch(propertyValidationResult);\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        if (typeof schema.additionalProperties === 'object') {\n            for (var _k = 0, unprocessedProperties_1 = unprocessedProperties; _k < unprocessedProperties_1.length; _k++) {\n                var propertyName = unprocessedProperties_1[_k];\n                var child = seenKeys[propertyName];\n                if (child) {\n                    var propertyValidationResult = new ValidationResult();\n                    validate(child, schema.additionalProperties, propertyValidationResult, matchingSchemas);\n                    validationResult.mergePropertyMatch(propertyValidationResult);\n                }\n            }\n        }\n        else if (schema.additionalProperties === false) {\n            if (unprocessedProperties.length > 0) {\n                for (var _l = 0, unprocessedProperties_2 = unprocessedProperties; _l < unprocessedProperties_2.length; _l++) {\n                    var propertyName = unprocessedProperties_2[_l];\n                    var child = seenKeys[propertyName];\n                    if (child) {\n                        var propertyNode = child.parent;\n                        validationResult.problems.push({\n                            location: { offset: propertyNode.keyNode.offset, length: propertyNode.keyNode.length },\n                            severity: DiagnosticSeverity.Warning,\n                            message: schema.errorMessage || localize('DisallowedExtraPropWarning', 'Property {0} is not allowed.', propertyName)\n                        });\n                    }\n                }\n            }\n        }\n        if (isNumber(schema.maxProperties)) {\n            if (node.properties.length > schema.maxProperties) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('MaxPropWarning', 'Object has more properties than limit of {0}.', schema.maxProperties)\n                });\n            }\n        }\n        if (isNumber(schema.minProperties)) {\n            if (node.properties.length < schema.minProperties) {\n                validationResult.problems.push({\n                    location: { offset: node.offset, length: node.length },\n                    severity: DiagnosticSeverity.Warning,\n                    message: localize('MinPropWarning', 'Object has fewer properties than the required number of {0}', schema.minProperties)\n                });\n            }\n        }\n        if (schema.dependencies) {\n            for (var _m = 0, _o = Object.keys(schema.dependencies); _m < _o.length; _m++) {\n                var key = _o[_m];\n                var prop = seenKeys[key];\n                if (prop) {\n                    var propertyDep = schema.dependencies[key];\n                    if (Array.isArray(propertyDep)) {\n                        for (var _p = 0, propertyDep_1 = propertyDep; _p < propertyDep_1.length; _p++) {\n                            var requiredProp = propertyDep_1[_p];\n                            if (!seenKeys[requiredProp]) {\n                                validationResult.problems.push({\n                                    location: { offset: node.offset, length: node.length },\n                                    severity: DiagnosticSeverity.Warning,\n                                    message: localize('RequiredDependentPropWarning', 'Object is missing property {0} required by property {1}.', requiredProp, key)\n                                });\n                            }\n                            else {\n                                validationResult.propertiesValueMatches++;\n                            }\n                        }\n                    }\n                    else {\n                        var propertySchema = asSchema(propertyDep);\n                        if (propertySchema) {\n                            var propertyValidationResult = new ValidationResult();\n                            validate(node, propertySchema, propertyValidationResult, matchingSchemas);\n                            validationResult.mergePropertyMatch(propertyValidationResult);\n                        }\n                    }\n                }\n            }\n        }\n        var propertyNames = asSchema(schema.propertyNames);\n        if (propertyNames) {\n            for (var _q = 0, _r = node.properties; _q < _r.length; _q++) {\n                var f = _r[_q];\n                var key = f.keyNode;\n                if (key) {\n                    validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance);\n                }\n            }\n        }\n    }\n}\nexport function parse(textDocument, config) {\n    var problems = [];\n    var lastProblemOffset = -1;\n    var text = textDocument.getText();\n    var scanner = Json.createScanner(text, false);\n    var commentRanges = config && config.collectComments ? [] : void 0;\n    function _scanNext() {\n        while (true) {\n            var token_1 = scanner.scan();\n            _checkScanError();\n            switch (token_1) {\n                case 12 /* LineCommentTrivia */:\n                case 13 /* BlockCommentTrivia */:\n                    if (Array.isArray(commentRanges)) {\n                        commentRanges.push(Range.create(textDocument.positionAt(scanner.getTokenOffset()), textDocument.positionAt(scanner.getTokenOffset() + scanner.getTokenLength())));\n                    }\n                    break;\n                case 15 /* Trivia */:\n                case 14 /* LineBreakTrivia */:\n                    break;\n                default:\n                    return token_1;\n            }\n        }\n    }\n    function _accept(token) {\n        if (scanner.getToken() === token) {\n            _scanNext();\n            return true;\n        }\n        return false;\n    }\n    function _errorAtRange(message, code, startOffset, endOffset, severity) {\n        if (severity === void 0) { severity = DiagnosticSeverity.Error; }\n        if (problems.length === 0 || startOffset !== lastProblemOffset) {\n            var range = Range.create(textDocument.positionAt(startOffset), textDocument.positionAt(endOffset));\n            problems.push(Diagnostic.create(range, message, severity, code, textDocument.languageId));\n            lastProblemOffset = startOffset;\n        }\n    }\n    function _error(message, code, node, skipUntilAfter, skipUntil) {\n        if (node === void 0) { node = null; }\n        if (skipUntilAfter === void 0) { skipUntilAfter = []; }\n        if (skipUntil === void 0) { skipUntil = []; }\n        var start = scanner.getTokenOffset();\n        var end = scanner.getTokenOffset() + scanner.getTokenLength();\n        if (start === end && start > 0) {\n            start--;\n            while (start > 0 && /\\s/.test(text.charAt(start))) {\n                start--;\n            }\n            end = start + 1;\n        }\n        _errorAtRange(message, code, start, end);\n        if (node) {\n            _finalize(node, false);\n        }\n        if (skipUntilAfter.length + skipUntil.length > 0) {\n            var token_2 = scanner.getToken();\n            while (token_2 !== 17 /* EOF */) {\n                if (skipUntilAfter.indexOf(token_2) !== -1) {\n                    _scanNext();\n                    break;\n                }\n                else if (skipUntil.indexOf(token_2) !== -1) {\n                    break;\n                }\n                token_2 = _scanNext();\n            }\n        }\n        return node;\n    }\n    function _checkScanError() {\n        switch (scanner.getTokenError()) {\n            case 4 /* InvalidUnicode */:\n                _error(localize('InvalidUnicode', 'Invalid unicode sequence in string.'), ErrorCode.InvalidUnicode);\n                return true;\n            case 5 /* InvalidEscapeCharacter */:\n                _error(localize('InvalidEscapeCharacter', 'Invalid escape character in string.'), ErrorCode.InvalidEscapeCharacter);\n                return true;\n            case 3 /* UnexpectedEndOfNumber */:\n                _error(localize('UnexpectedEndOfNumber', 'Unexpected end of number.'), ErrorCode.UnexpectedEndOfNumber);\n                return true;\n            case 1 /* UnexpectedEndOfComment */:\n                _error(localize('UnexpectedEndOfComment', 'Unexpected end of comment.'), ErrorCode.UnexpectedEndOfComment);\n                return true;\n            case 2 /* UnexpectedEndOfString */:\n                _error(localize('UnexpectedEndOfString', 'Unexpected end of string.'), ErrorCode.UnexpectedEndOfString);\n                return true;\n            case 6 /* InvalidCharacter */:\n                _error(localize('InvalidCharacter', 'Invalid characters in string. Control characters must be escaped.'), ErrorCode.InvalidCharacter);\n                return true;\n        }\n        return false;\n    }\n    function _finalize(node, scanNext) {\n        node.length = scanner.getTokenOffset() + scanner.getTokenLength() - node.offset;\n        if (scanNext) {\n            _scanNext();\n        }\n        return node;\n    }\n    function _parseArray(parent) {\n        if (scanner.getToken() !== 3 /* OpenBracketToken */) {\n            return null;\n        }\n        var node = new ArrayASTNodeImpl(parent, scanner.getTokenOffset());\n        _scanNext(); // consume OpenBracketToken\n        var count = 0;\n        var needsComma = false;\n        while (scanner.getToken() !== 4 /* CloseBracketToken */ && scanner.getToken() !== 17 /* EOF */) {\n            if (scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    _error(localize('ValueExpected', 'Value expected'), ErrorCode.ValueExpected);\n                }\n                var commaOffset = scanner.getTokenOffset();\n                _scanNext(); // consume comma\n                if (scanner.getToken() === 4 /* CloseBracketToken */) {\n                    if (needsComma) {\n                        _errorAtRange(localize('TrailingComma', 'Trailing comma'), ErrorCode.TrailingComma, commaOffset, commaOffset + 1);\n                    }\n                    continue;\n                }\n            }\n            else if (needsComma) {\n                _error(localize('ExpectedComma', 'Expected comma'), ErrorCode.CommaExpected);\n            }\n            var item = _parseValue(node, count++);\n            if (!item) {\n                _error(localize('PropertyExpected', 'Value expected'), ErrorCode.ValueExpected, null, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);\n            }\n            else {\n                node.items.push(item);\n            }\n            needsComma = true;\n        }\n        if (scanner.getToken() !== 4 /* CloseBracketToken */) {\n            return _error(localize('ExpectedCloseBracket', 'Expected comma or closing bracket'), ErrorCode.CommaOrCloseBacketExpected, node);\n        }\n        return _finalize(node, true);\n    }\n    function _parseProperty(parent, keysSeen) {\n        var node = new PropertyASTNodeImpl(parent, scanner.getTokenOffset());\n        var key = _parseString(node);\n        if (!key) {\n            if (scanner.getToken() === 16 /* Unknown */) {\n                // give a more helpful error message\n                _error(localize('DoubleQuotesExpected', 'Property keys must be doublequoted'), ErrorCode.Undefined);\n                var keyNode = new StringASTNodeImpl(node, scanner.getTokenOffset(), scanner.getTokenLength());\n                keyNode.value = scanner.getTokenValue();\n                key = keyNode;\n                _scanNext(); // consume Unknown\n            }\n            else {\n                return null;\n            }\n        }\n        node.keyNode = key;\n        var seen = keysSeen[key.value];\n        if (seen) {\n            _errorAtRange(localize('DuplicateKeyWarning', \"Duplicate object key\"), ErrorCode.DuplicateKey, node.keyNode.offset, node.keyNode.offset + node.keyNode.length, DiagnosticSeverity.Warning);\n            if (typeof seen === 'object') {\n                _errorAtRange(localize('DuplicateKeyWarning', \"Duplicate object key\"), ErrorCode.DuplicateKey, seen.keyNode.offset, seen.keyNode.offset + seen.keyNode.length, DiagnosticSeverity.Warning);\n            }\n            keysSeen[key.value] = true; // if the same key is duplicate again, avoid duplicate error reporting\n        }\n        else {\n            keysSeen[key.value] = node;\n        }\n        if (scanner.getToken() === 6 /* ColonToken */) {\n            node.colonOffset = scanner.getTokenOffset();\n            _scanNext(); // consume ColonToken\n        }\n        else {\n            _error(localize('ColonExpected', 'Colon expected'), ErrorCode.ColonExpected);\n            if (scanner.getToken() === 10 /* StringLiteral */ && textDocument.positionAt(key.offset + key.length).line < textDocument.positionAt(scanner.getTokenOffset()).line) {\n                node.length = key.length;\n                return node;\n            }\n        }\n        var value = _parseValue(node, key.value);\n        if (!value) {\n            return _error(localize('ValueExpected', 'Value expected'), ErrorCode.ValueExpected, node, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n        }\n        node.valueNode = value;\n        node.length = value.offset + value.length - node.offset;\n        return node;\n    }\n    function _parseObject(parent) {\n        if (scanner.getToken() !== 1 /* OpenBraceToken */) {\n            return null;\n        }\n        var node = new ObjectASTNodeImpl(parent, scanner.getTokenOffset());\n        var keysSeen = Object.create(null);\n        _scanNext(); // consume OpenBraceToken\n        var needsComma = false;\n        while (scanner.getToken() !== 2 /* CloseBraceToken */ && scanner.getToken() !== 17 /* EOF */) {\n            if (scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    _error(localize('PropertyExpected', 'Property expected'), ErrorCode.PropertyExpected);\n                }\n                var commaOffset = scanner.getTokenOffset();\n                _scanNext(); // consume comma\n                if (scanner.getToken() === 2 /* CloseBraceToken */) {\n                    if (needsComma) {\n                        _errorAtRange(localize('TrailingComma', 'Trailing comma'), ErrorCode.TrailingComma, commaOffset, commaOffset + 1);\n                    }\n                    continue;\n                }\n            }\n            else if (needsComma) {\n                _error(localize('ExpectedComma', 'Expected comma'), ErrorCode.CommaExpected);\n            }\n            var property = _parseProperty(node, keysSeen);\n            if (!property) {\n                _error(localize('PropertyExpected', 'Property expected'), ErrorCode.PropertyExpected, null, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            }\n            else {\n                node.properties.push(property);\n            }\n            needsComma = true;\n        }\n        if (scanner.getToken() !== 2 /* CloseBraceToken */) {\n            return _error(localize('ExpectedCloseBrace', 'Expected comma or closing brace'), ErrorCode.CommaOrCloseBraceExpected, node);\n        }\n        return _finalize(node, true);\n    }\n    function _parseString(parent) {\n        if (scanner.getToken() !== 10 /* StringLiteral */) {\n            return null;\n        }\n        var node = new StringASTNodeImpl(parent, scanner.getTokenOffset());\n        node.value = scanner.getTokenValue();\n        return _finalize(node, true);\n    }\n    function _parseNumber(parent) {\n        if (scanner.getToken() !== 11 /* NumericLiteral */) {\n            return null;\n        }\n        var node = new NumberASTNodeImpl(parent, scanner.getTokenOffset());\n        if (scanner.getTokenError() === 0 /* None */) {\n            var tokenValue = scanner.getTokenValue();\n            try {\n                var numberValue = JSON.parse(tokenValue);\n                if (!isNumber(numberValue)) {\n                    return _error(localize('InvalidNumberFormat', 'Invalid number format.'), ErrorCode.Undefined, node);\n                }\n                node.value = numberValue;\n            }\n            catch (e) {\n                return _error(localize('InvalidNumberFormat', 'Invalid number format.'), ErrorCode.Undefined, node);\n            }\n            node.isInteger = tokenValue.indexOf('.') === -1;\n        }\n        return _finalize(node, true);\n    }\n    function _parseLiteral(parent) {\n        var node;\n        switch (scanner.getToken()) {\n            case 7 /* NullKeyword */:\n                return _finalize(new NullASTNodeImpl(parent, scanner.getTokenOffset()), true);\n            case 8 /* TrueKeyword */:\n                return _finalize(new BooleanASTNodeImpl(parent, true, scanner.getTokenOffset()), true);\n            case 9 /* FalseKeyword */:\n                return _finalize(new BooleanASTNodeImpl(parent, false, scanner.getTokenOffset()), true);\n            default:\n                return null;\n        }\n    }\n    function _parseValue(parent, name) {\n        return _parseArray(parent) || _parseObject(parent) || _parseString(parent) || _parseNumber(parent) || _parseLiteral(parent);\n    }\n    var _root = null;\n    var token = _scanNext();\n    if (token !== 17 /* EOF */) {\n        _root = _parseValue(null, null);\n        if (!_root) {\n            _error(localize('Invalid symbol', 'Expected a JSON object, array or literal.'), ErrorCode.Undefined);\n        }\n        else if (scanner.getToken() !== 17 /* EOF */) {\n            _error(localize('End of file expected', 'End of file expected.'), ErrorCode.Undefined);\n        }\n    }\n    return new JSONDocument(_root, problems, commentRanges);\n}\n","/*---------------------------------------------------------------------------------------------\n*  Copyright (c) Microsoft Corporation. All rights reserved.\n*  Licensed under the MIT License. See License.txt in the project root for license information.\n*--------------------------------------------------------------------------------------------*/\nexport function stringifyObject(obj, indent, stringifyLiteral) {\n    if (obj !== null && typeof obj === 'object') {\n        var newIndent = indent + '\\t';\n        if (Array.isArray(obj)) {\n            if (obj.length === 0) {\n                return '[]';\n            }\n            var result = '[\\n';\n            for (var i = 0; i < obj.length; i++) {\n                result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);\n                if (i < obj.length - 1) {\n                    result += ',';\n                }\n                result += '\\n';\n            }\n            result += indent + ']';\n            return result;\n        }\n        else {\n            var keys = Object.keys(obj);\n            if (keys.length === 0) {\n                return '{}';\n            }\n            var result = '{\\n';\n            for (var i = 0; i < keys.length; i++) {\n                var key = keys[i];\n                result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);\n                if (i < keys.length - 1) {\n                    result += ',';\n                }\n                result += '\\n';\n            }\n            result += indent + '}';\n            return result;\n        }\n    }\n    return stringifyLiteral(obj);\n}\n","/*---------------------------------------------------------------------------------------------\n*  Copyright (c) Microsoft Corporation. All rights reserved.\n*  Licensed under the MIT License. See License.txt in the project root for license information.\n*--------------------------------------------------------------------------------------------*/\nexport function startsWith(haystack, needle) {\n    if (haystack.length < needle.length) {\n        return false;\n    }\n    for (var i = 0; i < needle.length; i++) {\n        if (haystack[i] !== needle[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Determines if haystack ends with needle.\n */\nexport function endsWith(haystack, needle) {\n    var diff = haystack.length - needle.length;\n    if (diff > 0) {\n        return haystack.lastIndexOf(needle) === diff;\n    }\n    else if (diff === 0) {\n        return haystack === needle;\n    }\n    else {\n        return false;\n    }\n}\nexport function convertSimple2RegExpPattern(pattern) {\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\nexport function repeat(value, count) {\n    var s = '';\n    while (count > 0) {\n        if ((count & 1) === 1) {\n            s += value;\n        }\n        value += value;\n        count = count >>> 1;\n    }\n    return s;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as Parser from '../parser/jsonParser.js';\nimport * as Json from '../../jsonc-parser/main.js';\nimport { stringifyObject } from '../utils/json.js';\nimport { endsWith } from '../utils/strings.js';\nimport { isDefined } from '../utils/objects.js';\nimport { CompletionItem, CompletionItemKind, Range, TextEdit, InsertTextFormat, MarkupKind } from '../../vscode-languageserver-types/main.js';\nimport * as nls from '../../../fillers/vscode-nls.js';\nvar localize = nls.loadMessageBundle();\nvar JSONCompletion = /** @class */ (function () {\n    function JSONCompletion(schemaService, contributions, promiseConstructor, clientCapabilities) {\n        if (contributions === void 0) { contributions = []; }\n        if (promiseConstructor === void 0) { promiseConstructor = Promise; }\n        if (clientCapabilities === void 0) { clientCapabilities = {}; }\n        this.schemaService = schemaService;\n        this.contributions = contributions;\n        this.promiseConstructor = promiseConstructor;\n        this.clientCapabilities = clientCapabilities;\n        this.templateVarIdCounter = 0;\n    }\n    JSONCompletion.prototype.doResolve = function (item) {\n        for (var i = this.contributions.length - 1; i >= 0; i--) {\n            if (this.contributions[i].resolveCompletion) {\n                var resolver = this.contributions[i].resolveCompletion(item);\n                if (resolver) {\n                    return resolver;\n                }\n            }\n        }\n        return this.promiseConstructor.resolve(item);\n    };\n    JSONCompletion.prototype.doComplete = function (document, position, doc) {\n        var _this = this;\n        var result = {\n            items: [],\n            isIncomplete: false\n        };\n        var offset = document.offsetAt(position);\n        var node = doc.getNodeFromOffset(offset, true);\n        if (this.isInComment(document, node ? node.offset : 0, offset)) {\n            return Promise.resolve(result);\n        }\n        var currentWord = this.getCurrentWord(document, offset);\n        var overwriteRange = null;\n        if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {\n            overwriteRange = Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));\n        }\n        else {\n            var overwriteStart = offset - currentWord.length;\n            if (overwriteStart > 0 && document.getText()[overwriteStart - 1] === '\"') {\n                overwriteStart--;\n            }\n            overwriteRange = Range.create(document.positionAt(overwriteStart), position);\n        }\n        var proposed = {};\n        var collector = {\n            add: function (suggestion) {\n                var existing = proposed[suggestion.label];\n                if (!existing) {\n                    proposed[suggestion.label] = suggestion;\n                    if (overwriteRange) {\n                        suggestion.textEdit = TextEdit.replace(overwriteRange, suggestion.insertText);\n                    }\n                    result.items.push(suggestion);\n                }\n                else if (!existing.documentation) {\n                    existing.documentation = suggestion.documentation;\n                }\n            },\n            setAsIncomplete: function () {\n                result.isIncomplete = true;\n            },\n            error: function (message) {\n                console.error(message);\n            },\n            log: function (message) {\n                console.log(message);\n            },\n            getNumberOfProposals: function () {\n                return result.items.length;\n            }\n        };\n        return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {\n            var collectionPromises = [];\n            var addValue = true;\n            var currentKey = '';\n            var currentProperty = null;\n            if (node) {\n                if (node.type === 'string') {\n                    var parent = node.parent;\n                    if (parent && parent.type === 'property' && parent.keyNode === node) {\n                        addValue = !parent.valueNode;\n                        currentProperty = parent;\n                        currentKey = document.getText().substr(node.offset + 1, node.length - 2);\n                        if (parent) {\n                            node = parent.parent;\n                        }\n                    }\n                }\n            }\n            // proposals for properties\n            if (node && node.type === 'object') {\n                // don't suggest keys when the cursor is just before the opening curly brace\n                if (node.offset === offset) {\n                    return result;\n                }\n                // don't suggest properties that are already present\n                var properties = node.properties;\n                properties.forEach(function (p) {\n                    if (!currentProperty || currentProperty !== p) {\n                        proposed[p.keyNode.value] = CompletionItem.create('__');\n                    }\n                });\n                var separatorAfter_1 = '';\n                if (addValue) {\n                    separatorAfter_1 = _this.evaluateSeparatorAfter(document, document.offsetAt(overwriteRange.end));\n                }\n                if (schema) {\n                    // property proposals with schema\n                    _this.getPropertyCompletions(schema, doc, node, addValue, separatorAfter_1, collector);\n                }\n                else {\n                    // property proposals without schema\n                    _this.getSchemaLessPropertyCompletions(doc, node, currentKey, collector);\n                }\n                var location_1 = Parser.getNodePath(node);\n                _this.contributions.forEach(function (contribution) {\n                    var collectPromise = contribution.collectPropertyCompletions(document.uri, location_1, currentWord, addValue, separatorAfter_1 === '', collector);\n                    if (collectPromise) {\n                        collectionPromises.push(collectPromise);\n                    }\n                });\n                if ((!schema && currentWord.length > 0 && document.getText().charAt(offset - currentWord.length - 1) !== '\"')) {\n                    collector.add({\n                        kind: CompletionItemKind.Property,\n                        label: _this.getLabelForValue(currentWord),\n                        insertText: _this.getInsertTextForProperty(currentWord, null, false, separatorAfter_1),\n                        insertTextFormat: InsertTextFormat.Snippet, documentation: '',\n                    });\n                    collector.setAsIncomplete();\n                }\n            }\n            // proposals for values\n            var types = {};\n            if (schema) {\n                // value proposals with schema\n                _this.getValueCompletions(schema, doc, node, offset, document, collector, types);\n            }\n            else {\n                // value proposals without schema\n                _this.getSchemaLessValueCompletions(doc, node, offset, document, collector);\n            }\n            if (_this.contributions.length > 0) {\n                _this.getContributedValueCompletions(doc, node, offset, document, collector, collectionPromises);\n            }\n            return _this.promiseConstructor.all(collectionPromises).then(function () {\n                if (collector.getNumberOfProposals() === 0) {\n                    var offsetForSeparator = offset;\n                    if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {\n                        offsetForSeparator = node.offset + node.length;\n                    }\n                    var separatorAfter = _this.evaluateSeparatorAfter(document, offsetForSeparator);\n                    _this.addFillerValueCompletions(types, separatorAfter, collector);\n                }\n                return result;\n            });\n        });\n    };\n    JSONCompletion.prototype.getPropertyCompletions = function (schema, doc, node, addValue, separatorAfter, collector) {\n        var _this = this;\n        var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);\n        matchingSchemas.forEach(function (s) {\n            if (s.node === node && !s.inverted) {\n                var schemaProperties_1 = s.schema.properties;\n                if (schemaProperties_1) {\n                    Object.keys(schemaProperties_1).forEach(function (key) {\n                        var propertySchema = schemaProperties_1[key];\n                        if (typeof propertySchema === 'object' && !propertySchema.deprecationMessage && !propertySchema.doNotSuggest) {\n                            var proposal = {\n                                kind: CompletionItemKind.Property,\n                                label: _this.sanitizeLabel(key),\n                                insertText: _this.getInsertTextForProperty(key, propertySchema, addValue, separatorAfter),\n                                insertTextFormat: InsertTextFormat.Snippet,\n                                filterText: _this.getFilterTextForValue(key),\n                                documentation: _this.fromMarkup(propertySchema.markdownDescription) || propertySchema.description || '',\n                            };\n                            if (endsWith(proposal.insertText, \"$1\" + separatorAfter)) {\n                                proposal.command = {\n                                    title: 'Suggest',\n                                    command: 'editor.action.triggerSuggest'\n                                };\n                            }\n                            collector.add(proposal);\n                        }\n                    });\n                }\n            }\n        });\n    };\n    JSONCompletion.prototype.getSchemaLessPropertyCompletions = function (doc, node, currentKey, collector) {\n        var _this = this;\n        var collectCompletionsForSimilarObject = function (obj) {\n            obj.properties.forEach(function (p) {\n                var key = p.keyNode.value;\n                collector.add({\n                    kind: CompletionItemKind.Property,\n                    label: _this.sanitizeLabel(key),\n                    insertText: _this.getInsertTextForValue(key, ''),\n                    insertTextFormat: InsertTextFormat.Snippet,\n                    filterText: _this.getFilterTextForValue(key),\n                    documentation: ''\n                });\n            });\n        };\n        if (node.parent) {\n            if (node.parent.type === 'property') {\n                // if the object is a property value, check the tree for other objects that hang under a property of the same name\n                var parentKey_1 = node.parent.keyNode.value;\n                doc.visit(function (n) {\n                    if (n.type === 'property' && n !== node.parent && n.keyNode.value === parentKey_1 && n.valueNode && n.valueNode.type === 'object') {\n                        collectCompletionsForSimilarObject(n.valueNode);\n                    }\n                    return true;\n                });\n            }\n            else if (node.parent.type === 'array') {\n                // if the object is in an array, use all other array elements as similar objects\n                node.parent.items.forEach(function (n) {\n                    if (n.type === 'object' && n !== node) {\n                        collectCompletionsForSimilarObject(n);\n                    }\n                });\n            }\n        }\n        else if (node.type === 'object') {\n            collector.add({\n                kind: CompletionItemKind.Property,\n                label: '$schema',\n                insertText: this.getInsertTextForProperty('$schema', null, true, ''),\n                insertTextFormat: InsertTextFormat.Snippet, documentation: '',\n                filterText: this.getFilterTextForValue(\"$schema\")\n            });\n        }\n    };\n    JSONCompletion.prototype.getSchemaLessValueCompletions = function (doc, node, offset, document, collector) {\n        var _this = this;\n        var offsetForSeparator = offset;\n        if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {\n            offsetForSeparator = node.offset + node.length;\n            node = node.parent;\n        }\n        if (!node) {\n            collector.add({\n                kind: this.getSuggestionKind('object'),\n                label: 'Empty object',\n                insertText: this.getInsertTextForValue({}, ''),\n                insertTextFormat: InsertTextFormat.Snippet,\n                documentation: ''\n            });\n            collector.add({\n                kind: this.getSuggestionKind('array'),\n                label: 'Empty array',\n                insertText: this.getInsertTextForValue([], ''),\n                insertTextFormat: InsertTextFormat.Snippet,\n                documentation: ''\n            });\n            return;\n        }\n        var separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);\n        var collectSuggestionsForValues = function (value) {\n            if (!Parser.contains(value.parent, offset, true)) {\n                collector.add({\n                    kind: _this.getSuggestionKind(value.type),\n                    label: _this.getLabelTextForMatchingNode(value, document),\n                    insertText: _this.getInsertTextForMatchingNode(value, document, separatorAfter),\n                    insertTextFormat: InsertTextFormat.Snippet, documentation: ''\n                });\n            }\n            if (value.type === 'boolean') {\n                _this.addBooleanValueCompletion(!value.value, separatorAfter, collector);\n            }\n        };\n        if (node.type === 'property') {\n            if (offset > node.colonOffset) {\n                var valueNode = node.valueNode;\n                if (valueNode && (offset > (valueNode.offset + valueNode.length) || valueNode.type === 'object' || valueNode.type === 'array')) {\n                    return;\n                }\n                // suggest values at the same key\n                var parentKey_2 = node.keyNode.value;\n                doc.visit(function (n) {\n                    if (n.type === 'property' && n.keyNode.value === parentKey_2 && n.valueNode) {\n                        collectSuggestionsForValues(n.valueNode);\n                    }\n                    return true;\n                });\n                if (parentKey_2 === '$schema' && node.parent && !node.parent.parent) {\n                    this.addDollarSchemaCompletions(separatorAfter, collector);\n                }\n            }\n        }\n        if (node.type === 'array') {\n            if (node.parent && node.parent.type === 'property') {\n                // suggest items of an array at the same key\n                var parentKey_3 = node.parent.keyNode.value;\n                doc.visit(function (n) {\n                    if (n.type === 'property' && n.keyNode.value === parentKey_3 && n.valueNode && n.valueNode.type === 'array') {\n                        n.valueNode.items.forEach(collectSuggestionsForValues);\n                    }\n                    return true;\n                });\n            }\n            else {\n                // suggest items in the same array\n                node.items.forEach(collectSuggestionsForValues);\n            }\n        }\n    };\n    JSONCompletion.prototype.getValueCompletions = function (schema, doc, node, offset, document, collector, types) {\n        var _this = this;\n        var offsetForSeparator = offset;\n        var parentKey = null;\n        var valueNode = null;\n        if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null')) {\n            offsetForSeparator = node.offset + node.length;\n            valueNode = node;\n            node = node.parent;\n        }\n        if (!node) {\n            this.addSchemaValueCompletions(schema.schema, '', collector, types);\n            return;\n        }\n        if ((node.type === 'property') && offset > node.colonOffset) {\n            var valueNode_1 = node.valueNode;\n            if (valueNode_1 && offset > (valueNode_1.offset + valueNode_1.length)) {\n                return; // we are past the value node\n            }\n            parentKey = node.keyNode.value;\n            node = node.parent;\n        }\n        if (node && (parentKey !== null || node.type === 'array')) {\n            var separatorAfter_2 = this.evaluateSeparatorAfter(document, offsetForSeparator);\n            var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset, valueNode);\n            matchingSchemas.forEach(function (s) {\n                if (s.node === node && !s.inverted && s.schema) {\n                    if (node.type === 'array' && s.schema.items) {\n                        if (Array.isArray(s.schema.items)) {\n                            var index = _this.findItemAtOffset(node, document, offset);\n                            if (index < s.schema.items.length) {\n                                _this.addSchemaValueCompletions(s.schema.items[index], separatorAfter_2, collector, types);\n                            }\n                        }\n                        else {\n                            _this.addSchemaValueCompletions(s.schema.items, separatorAfter_2, collector, types);\n                        }\n                    }\n                    if (s.schema.properties) {\n                        var propertySchema = s.schema.properties[parentKey];\n                        if (propertySchema) {\n                            _this.addSchemaValueCompletions(propertySchema, separatorAfter_2, collector, types);\n                        }\n                    }\n                }\n            });\n            if (parentKey === '$schema' && !node.parent) {\n                this.addDollarSchemaCompletions(separatorAfter_2, collector);\n            }\n            if (types['boolean']) {\n                this.addBooleanValueCompletion(true, separatorAfter_2, collector);\n                this.addBooleanValueCompletion(false, separatorAfter_2, collector);\n            }\n            if (types['null']) {\n                this.addNullValueCompletion(separatorAfter_2, collector);\n            }\n        }\n    };\n    JSONCompletion.prototype.getContributedValueCompletions = function (doc, node, offset, document, collector, collectionPromises) {\n        if (!node) {\n            this.contributions.forEach(function (contribution) {\n                var collectPromise = contribution.collectDefaultCompletions(document.uri, collector);\n                if (collectPromise) {\n                    collectionPromises.push(collectPromise);\n                }\n            });\n        }\n        else {\n            if (node.type === 'string' || node.type === 'number' || node.type === 'boolean' || node.type === 'null') {\n                node = node.parent;\n            }\n            if ((node.type === 'property') && offset > node.colonOffset) {\n                var parentKey_4 = node.keyNode.value;\n                var valueNode = node.valueNode;\n                if (!valueNode || offset <= (valueNode.offset + valueNode.length)) {\n                    var location_2 = Parser.getNodePath(node.parent);\n                    this.contributions.forEach(function (contribution) {\n                        var collectPromise = contribution.collectValueCompletions(document.uri, location_2, parentKey_4, collector);\n                        if (collectPromise) {\n                            collectionPromises.push(collectPromise);\n                        }\n                    });\n                }\n            }\n        }\n    };\n    JSONCompletion.prototype.addSchemaValueCompletions = function (schema, separatorAfter, collector, types) {\n        var _this = this;\n        if (typeof schema === 'object') {\n            this.addEnumValueCompletions(schema, separatorAfter, collector);\n            this.addDefaultValueCompletions(schema, separatorAfter, collector);\n            this.collectTypes(schema, types);\n            if (Array.isArray(schema.allOf)) {\n                schema.allOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });\n            }\n            if (Array.isArray(schema.anyOf)) {\n                schema.anyOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });\n            }\n            if (Array.isArray(schema.oneOf)) {\n                schema.oneOf.forEach(function (s) { return _this.addSchemaValueCompletions(s, separatorAfter, collector, types); });\n            }\n        }\n    };\n    JSONCompletion.prototype.addDefaultValueCompletions = function (schema, separatorAfter, collector, arrayDepth) {\n        var _this = this;\n        if (arrayDepth === void 0) { arrayDepth = 0; }\n        var hasProposals = false;\n        if (isDefined(schema.default)) {\n            var type = schema.type;\n            var value = schema.default;\n            for (var i = arrayDepth; i > 0; i--) {\n                value = [value];\n                type = 'array';\n            }\n            collector.add({\n                kind: this.getSuggestionKind(type),\n                label: this.getLabelForValue(value),\n                insertText: this.getInsertTextForValue(value, separatorAfter),\n                insertTextFormat: InsertTextFormat.Snippet,\n                detail: localize('json.suggest.default', 'Default value')\n            });\n            hasProposals = true;\n        }\n        if (Array.isArray(schema.examples)) {\n            schema.examples.forEach(function (example) {\n                var type = schema.type;\n                var value = example;\n                for (var i = arrayDepth; i > 0; i--) {\n                    value = [value];\n                    type = 'array';\n                }\n                collector.add({\n                    kind: _this.getSuggestionKind(type),\n                    label: _this.getLabelForValue(value),\n                    insertText: _this.getInsertTextForValue(value, separatorAfter),\n                    insertTextFormat: InsertTextFormat.Snippet\n                });\n                hasProposals = true;\n            });\n        }\n        if (Array.isArray(schema.defaultSnippets)) {\n            schema.defaultSnippets.forEach(function (s) {\n                var type = schema.type;\n                var value = s.body;\n                var label = s.label;\n                var insertText;\n                var filterText;\n                if (isDefined(value)) {\n                    var type_1 = schema.type;\n                    for (var i = arrayDepth; i > 0; i--) {\n                        value = [value];\n                        type_1 = 'array';\n                    }\n                    insertText = _this.getInsertTextForSnippetValue(value, separatorAfter);\n                    filterText = _this.getFilterTextForSnippetValue(value);\n                    label = label || _this.getLabelForSnippetValue(value);\n                }\n                else if (typeof s.bodyText === 'string') {\n                    var prefix = '', suffix = '', indent = '';\n                    for (var i = arrayDepth; i > 0; i--) {\n                        prefix = prefix + indent + '[\\n';\n                        suffix = suffix + '\\n' + indent + ']';\n                        indent += '\\t';\n                        type = 'array';\n                    }\n                    insertText = prefix + indent + s.bodyText.split('\\n').join('\\n' + indent) + suffix + separatorAfter;\n                    label = label || _this.sanitizeLabel(insertText),\n                        filterText = insertText.replace(/[\\n]/g, ''); // remove new lines\n                }\n                collector.add({\n                    kind: _this.getSuggestionKind(type),\n                    label: label,\n                    documentation: _this.fromMarkup(s.markdownDescription) || s.description,\n                    insertText: insertText,\n                    insertTextFormat: InsertTextFormat.Snippet,\n                    filterText: filterText\n                });\n                hasProposals = true;\n            });\n        }\n        if (!hasProposals && typeof schema.items === 'object' && !Array.isArray(schema.items)) {\n            this.addDefaultValueCompletions(schema.items, separatorAfter, collector, arrayDepth + 1);\n        }\n    };\n    JSONCompletion.prototype.addEnumValueCompletions = function (schema, separatorAfter, collector) {\n        if (isDefined(schema.const)) {\n            collector.add({\n                kind: this.getSuggestionKind(schema.type),\n                label: this.getLabelForValue(schema.const),\n                insertText: this.getInsertTextForValue(schema.const, separatorAfter),\n                insertTextFormat: InsertTextFormat.Snippet,\n                documentation: this.fromMarkup(schema.markdownDescription) || schema.description\n            });\n        }\n        if (Array.isArray(schema.enum)) {\n            for (var i = 0, length = schema.enum.length; i < length; i++) {\n                var enm = schema.enum[i];\n                var documentation = this.fromMarkup(schema.markdownDescription) || schema.description;\n                if (schema.markdownEnumDescriptions && i < schema.markdownEnumDescriptions.length && this.doesSupportMarkdown()) {\n                    documentation = this.fromMarkup(schema.markdownEnumDescriptions[i]);\n                }\n                else if (schema.enumDescriptions && i < schema.enumDescriptions.length) {\n                    documentation = schema.enumDescriptions[i];\n                }\n                collector.add({\n                    kind: this.getSuggestionKind(schema.type),\n                    label: this.getLabelForValue(enm),\n                    insertText: this.getInsertTextForValue(enm, separatorAfter),\n                    insertTextFormat: InsertTextFormat.Snippet,\n                    documentation: documentation\n                });\n            }\n        }\n    };\n    JSONCompletion.prototype.collectTypes = function (schema, types) {\n        if (Array.isArray(schema.enum) || isDefined(schema.const)) {\n            return;\n        }\n        var type = schema.type;\n        if (Array.isArray(type)) {\n            type.forEach(function (t) { return types[t] = true; });\n        }\n        else {\n            types[type] = true;\n        }\n    };\n    JSONCompletion.prototype.addFillerValueCompletions = function (types, separatorAfter, collector) {\n        if (types['object']) {\n            collector.add({\n                kind: this.getSuggestionKind('object'),\n                label: '{}',\n                insertText: this.getInsertTextForGuessedValue({}, separatorAfter),\n                insertTextFormat: InsertTextFormat.Snippet,\n                detail: localize('defaults.object', 'New object'),\n                documentation: ''\n            });\n        }\n        if (types['array']) {\n            collector.add({\n                kind: this.getSuggestionKind('array'),\n                label: '[]',\n                insertText: this.getInsertTextForGuessedValue([], separatorAfter),\n                insertTextFormat: InsertTextFormat.Snippet,\n                detail: localize('defaults.array', 'New array'),\n                documentation: ''\n            });\n        }\n    };\n    JSONCompletion.prototype.addBooleanValueCompletion = function (value, separatorAfter, collector) {\n        collector.add({\n            kind: this.getSuggestionKind('boolean'),\n            label: value ? 'true' : 'false',\n            insertText: this.getInsertTextForValue(value, separatorAfter),\n            insertTextFormat: InsertTextFormat.Snippet,\n            documentation: ''\n        });\n    };\n    JSONCompletion.prototype.addNullValueCompletion = function (separatorAfter, collector) {\n        collector.add({\n            kind: this.getSuggestionKind('null'),\n            label: 'null',\n            insertText: 'null' + separatorAfter,\n            insertTextFormat: InsertTextFormat.Snippet,\n            documentation: ''\n        });\n    };\n    JSONCompletion.prototype.addDollarSchemaCompletions = function (separatorAfter, collector) {\n        var _this = this;\n        var schemaIds = this.schemaService.getRegisteredSchemaIds(function (schema) { return schema === 'http' || schema === 'https'; });\n        schemaIds.forEach(function (schemaId) { return collector.add({\n            kind: CompletionItemKind.Module,\n            label: _this.getLabelForValue(schemaId),\n            filterText: _this.getFilterTextForValue(schemaId),\n            insertText: _this.getInsertTextForValue(schemaId, separatorAfter),\n            insertTextFormat: InsertTextFormat.Snippet, documentation: ''\n        }); });\n    };\n    JSONCompletion.prototype.sanitizeLabel = function (label) {\n        label = label.replace(/[\\n]/g, '↵');\n        if (label.length > 57) {\n            label = label.substr(0, 57).trim() + '...';\n        }\n        return label;\n    };\n    JSONCompletion.prototype.getLabelForValue = function (value) {\n        return this.sanitizeLabel(JSON.stringify(value));\n    };\n    JSONCompletion.prototype.getFilterTextForValue = function (value) {\n        return JSON.stringify(value);\n    };\n    JSONCompletion.prototype.getFilterTextForSnippetValue = function (value) {\n        return JSON.stringify(value).replace(/\\$\\{\\d+:([^}]+)\\}|\\$\\d+/g, '$1');\n    };\n    JSONCompletion.prototype.getLabelForSnippetValue = function (value) {\n        var label = JSON.stringify(value);\n        label = label.replace(/\\$\\{\\d+:([^}]+)\\}|\\$\\d+/g, '$1');\n        return this.sanitizeLabel(label);\n    };\n    JSONCompletion.prototype.getInsertTextForPlainText = function (text) {\n        return text.replace(/[\\\\\\$\\}]/g, '\\\\$&'); // escape $, \\ and } \n    };\n    JSONCompletion.prototype.getInsertTextForValue = function (value, separatorAfter) {\n        var text = JSON.stringify(value, null, '\\t');\n        if (text === '{}') {\n            return '{$1}' + separatorAfter;\n        }\n        else if (text === '[]') {\n            return '[$1]' + separatorAfter;\n        }\n        return this.getInsertTextForPlainText(text + separatorAfter);\n    };\n    JSONCompletion.prototype.getInsertTextForSnippetValue = function (value, separatorAfter) {\n        var replacer = function (value) {\n            if (typeof value === 'string') {\n                if (value[0] === '^') {\n                    return value.substr(1);\n                }\n            }\n            return JSON.stringify(value);\n        };\n        return stringifyObject(value, '', replacer) + separatorAfter;\n    };\n    JSONCompletion.prototype.getInsertTextForGuessedValue = function (value, separatorAfter) {\n        switch (typeof value) {\n            case 'object':\n                if (value === null) {\n                    return '${1:null}' + separatorAfter;\n                }\n                return this.getInsertTextForValue(value, separatorAfter);\n            case 'string':\n                var snippetValue = JSON.stringify(value);\n                snippetValue = snippetValue.substr(1, snippetValue.length - 2); // remove quotes\n                snippetValue = this.getInsertTextForPlainText(snippetValue); // escape \\ and }\n                return '\"${1:' + snippetValue + '}\"' + separatorAfter;\n            case 'number':\n            case 'boolean':\n                return '${1:' + JSON.stringify(value) + '}' + separatorAfter;\n        }\n        return this.getInsertTextForValue(value, separatorAfter);\n    };\n    JSONCompletion.prototype.getSuggestionKind = function (type) {\n        if (Array.isArray(type)) {\n            var array = type;\n            type = array.length > 0 ? array[0] : null;\n        }\n        if (!type) {\n            return CompletionItemKind.Value;\n        }\n        switch (type) {\n            case 'string': return CompletionItemKind.Value;\n            case 'object': return CompletionItemKind.Module;\n            case 'property': return CompletionItemKind.Property;\n            default: return CompletionItemKind.Value;\n        }\n    };\n    JSONCompletion.prototype.getLabelTextForMatchingNode = function (node, document) {\n        switch (node.type) {\n            case 'array':\n                return '[]';\n            case 'object':\n                return '{}';\n            default:\n                var content = document.getText().substr(node.offset, node.length);\n                return content;\n        }\n    };\n    JSONCompletion.prototype.getInsertTextForMatchingNode = function (node, document, separatorAfter) {\n        switch (node.type) {\n            case 'array':\n                return this.getInsertTextForValue([], separatorAfter);\n            case 'object':\n                return this.getInsertTextForValue({}, separatorAfter);\n            default:\n                var content = document.getText().substr(node.offset, node.length) + separatorAfter;\n                return this.getInsertTextForPlainText(content);\n        }\n    };\n    JSONCompletion.prototype.getInsertTextForProperty = function (key, propertySchema, addValue, separatorAfter) {\n        var propertyText = this.getInsertTextForValue(key, '');\n        if (!addValue) {\n            return propertyText;\n        }\n        var resultText = propertyText + ': ';\n        var value;\n        var nValueProposals = 0;\n        if (propertySchema) {\n            if (Array.isArray(propertySchema.defaultSnippets)) {\n                if (propertySchema.defaultSnippets.length === 1) {\n                    var body = propertySchema.defaultSnippets[0].body;\n                    if (isDefined(body)) {\n                        value = this.getInsertTextForSnippetValue(body, '');\n                    }\n                }\n                nValueProposals += propertySchema.defaultSnippets.length;\n            }\n            if (propertySchema.enum) {\n                if (!value && propertySchema.enum.length === 1) {\n                    value = this.getInsertTextForGuessedValue(propertySchema.enum[0], '');\n                }\n                nValueProposals += propertySchema.enum.length;\n            }\n            if (isDefined(propertySchema.default)) {\n                if (!value) {\n                    value = this.getInsertTextForGuessedValue(propertySchema.default, '');\n                }\n                nValueProposals++;\n            }\n            if (nValueProposals === 0) {\n                var type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;\n                if (!type) {\n                    if (propertySchema.properties) {\n                        type = 'object';\n                    }\n                    else if (propertySchema.items) {\n                        type = 'array';\n                    }\n                }\n                switch (type) {\n                    case 'boolean':\n                        value = '$1';\n                        break;\n                    case 'string':\n                        value = '\"$1\"';\n                        break;\n                    case 'object':\n                        value = '{$1}';\n                        break;\n                    case 'array':\n                        value = '[$1]';\n                        break;\n                    case 'number':\n                    case 'integer':\n                        value = '${1:0}';\n                        break;\n                    case 'null':\n                        value = '${1:null}';\n                        break;\n                    default:\n                        return propertyText;\n                }\n            }\n        }\n        if (!value || nValueProposals > 1) {\n            value = '$1';\n        }\n        return resultText + value + separatorAfter;\n    };\n    JSONCompletion.prototype.getCurrentWord = function (document, offset) {\n        var i = offset - 1;\n        var text = document.getText();\n        while (i >= 0 && ' \\t\\n\\r\\v\":{[,]}'.indexOf(text.charAt(i)) === -1) {\n            i--;\n        }\n        return text.substring(i + 1, offset);\n    };\n    JSONCompletion.prototype.evaluateSeparatorAfter = function (document, offset) {\n        var scanner = Json.createScanner(document.getText(), true);\n        scanner.setPosition(offset);\n        var token = scanner.scan();\n        switch (token) {\n            case 5 /* CommaToken */:\n            case 2 /* CloseBraceToken */:\n            case 4 /* CloseBracketToken */:\n            case 17 /* EOF */:\n                return '';\n            default:\n                return ',';\n        }\n    };\n    JSONCompletion.prototype.findItemAtOffset = function (node, document, offset) {\n        var scanner = Json.createScanner(document.getText(), true);\n        var children = node.items;\n        for (var i = children.length - 1; i >= 0; i--) {\n            var child = children[i];\n            if (offset > child.offset + child.length) {\n                scanner.setPosition(child.offset + child.length);\n                var token = scanner.scan();\n                if (token === 5 /* CommaToken */ && offset >= scanner.getTokenOffset() + scanner.getTokenLength()) {\n                    return i + 1;\n                }\n                return i;\n            }\n            else if (offset >= child.offset) {\n                return i;\n            }\n        }\n        return 0;\n    };\n    JSONCompletion.prototype.isInComment = function (document, start, offset) {\n        var scanner = Json.createScanner(document.getText(), false);\n        scanner.setPosition(start);\n        var token = scanner.scan();\n        while (token !== 17 /* EOF */ && (scanner.getTokenOffset() + scanner.getTokenLength() < offset)) {\n            token = scanner.scan();\n        }\n        return (token === 12 /* LineCommentTrivia */ || token === 13 /* BlockCommentTrivia */) && scanner.getTokenOffset() <= offset;\n    };\n    JSONCompletion.prototype.fromMarkup = function (markupString) {\n        if (markupString && this.doesSupportMarkdown()) {\n            return {\n                kind: MarkupKind.Markdown,\n                value: markupString\n            };\n        }\n        return undefined;\n    };\n    JSONCompletion.prototype.doesSupportMarkdown = function () {\n        if (!isDefined(this.supportsMarkdown)) {\n            var completion = this.clientCapabilities.textDocument && this.clientCapabilities.textDocument.completion;\n            this.supportsMarkdown = completion && completion.completionItem && Array.isArray(completion.completionItem.documentationFormat) && completion.completionItem.documentationFormat.indexOf(MarkupKind.Markdown) !== -1;\n        }\n        return this.supportsMarkdown;\n    };\n    return JSONCompletion;\n}());\nexport { JSONCompletion };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as Parser from '../parser/jsonParser.js';\nimport { Range } from '../../vscode-languageserver-types/main.js';\nvar JSONHover = /** @class */ (function () {\n    function JSONHover(schemaService, contributions, promiseConstructor) {\n        if (contributions === void 0) { contributions = []; }\n        this.schemaService = schemaService;\n        this.contributions = contributions;\n        this.promise = promiseConstructor || Promise;\n    }\n    JSONHover.prototype.doHover = function (document, position, doc) {\n        var offset = document.offsetAt(position);\n        var node = doc.getNodeFromOffset(offset);\n        if (!node || (node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1) {\n            return this.promise.resolve(null);\n        }\n        var hoverRangeNode = node;\n        // use the property description when hovering over an object key\n        if (node.type === 'string') {\n            var parent = node.parent;\n            if (parent && parent.type === 'property' && parent.keyNode === node) {\n                node = parent.valueNode;\n                if (!node) {\n                    return this.promise.resolve(null);\n                }\n            }\n        }\n        var hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));\n        var createHover = function (contents) {\n            var result = {\n                contents: contents,\n                range: hoverRange\n            };\n            return result;\n        };\n        var location = Parser.getNodePath(node);\n        for (var i = this.contributions.length - 1; i >= 0; i--) {\n            var contribution = this.contributions[i];\n            var promise = contribution.getInfoContribution(document.uri, location);\n            if (promise) {\n                return promise.then(function (htmlContent) { return createHover(htmlContent); });\n            }\n        }\n        return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {\n            if (schema) {\n                var matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);\n                var title_1 = null;\n                var markdownDescription_1 = null;\n                var markdownEnumValueDescription_1 = null, enumValue_1 = null;\n                matchingSchemas.every(function (s) {\n                    if (s.node === node && !s.inverted && s.schema) {\n                        title_1 = title_1 || s.schema.title;\n                        markdownDescription_1 = markdownDescription_1 || s.schema.markdownDescription || toMarkdown(s.schema.description);\n                        if (s.schema.enum) {\n                            var idx = s.schema.enum.indexOf(Parser.getNodeValue(node));\n                            if (s.schema.markdownEnumDescriptions) {\n                                markdownEnumValueDescription_1 = s.schema.markdownEnumDescriptions[idx];\n                            }\n                            else if (s.schema.enumDescriptions) {\n                                markdownEnumValueDescription_1 = toMarkdown(s.schema.enumDescriptions[idx]);\n                            }\n                            if (markdownEnumValueDescription_1) {\n                                enumValue_1 = s.schema.enum[idx];\n                                if (typeof enumValue_1 !== 'string') {\n                                    enumValue_1 = JSON.stringify(enumValue_1);\n                                }\n                            }\n                        }\n                    }\n                    return true;\n                });\n                var result = '';\n                if (title_1) {\n                    result = toMarkdown(title_1);\n                }\n                if (markdownDescription_1) {\n                    if (result.length > 0) {\n                        result += \"\\n\\n\";\n                    }\n                    result += markdownDescription_1;\n                }\n                if (markdownEnumValueDescription_1) {\n                    if (result.length > 0) {\n                        result += \"\\n\\n\";\n                    }\n                    result += \"`\" + toMarkdown(enumValue_1) + \"`: \" + markdownEnumValueDescription_1;\n                }\n                return createHover([result]);\n            }\n            return null;\n        });\n    };\n    return JSONHover;\n}());\nexport { JSONHover };\nfunction toMarkdown(plain) {\n    if (plain) {\n        var res = plain.replace(/([^\\n\\r])(\\r?\\n)([^\\n\\r])/gm, '$1\\n\\n$3'); // single new lines to \\n\\n (Markdown paragraph)\n        return res.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, \"\\\\$&\"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\n    }\n    return void 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as Json from '../../jsonc-parser/main.js';\nimport URI from '../../vscode-uri/index.js';\nimport * as Strings from '../utils/strings.js';\nimport * as Parser from '../parser/jsonParser.js';\nimport * as nls from '../../../fillers/vscode-nls.js';\nvar localize = nls.loadMessageBundle();\nvar FilePatternAssociation = /** @class */ (function () {\n    function FilePatternAssociation(pattern) {\n        try {\n            this.patternRegExp = new RegExp(Strings.convertSimple2RegExpPattern(pattern) + '$');\n        }\n        catch (e) {\n            // invalid pattern\n            this.patternRegExp = null;\n        }\n        this.schemas = [];\n    }\n    FilePatternAssociation.prototype.addSchema = function (id) {\n        this.schemas.push(id);\n    };\n    FilePatternAssociation.prototype.matchesPattern = function (fileName) {\n        return this.patternRegExp && this.patternRegExp.test(fileName);\n    };\n    FilePatternAssociation.prototype.getSchemas = function () {\n        return this.schemas;\n    };\n    return FilePatternAssociation;\n}());\nvar SchemaHandle = /** @class */ (function () {\n    function SchemaHandle(service, url, unresolvedSchemaContent) {\n        this.service = service;\n        this.url = url;\n        this.dependencies = {};\n        if (unresolvedSchemaContent) {\n            this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));\n        }\n    }\n    SchemaHandle.prototype.getUnresolvedSchema = function () {\n        if (!this.unresolvedSchema) {\n            this.unresolvedSchema = this.service.loadSchema(this.url);\n        }\n        return this.unresolvedSchema;\n    };\n    SchemaHandle.prototype.getResolvedSchema = function () {\n        var _this = this;\n        if (!this.resolvedSchema) {\n            this.resolvedSchema = this.getUnresolvedSchema().then(function (unresolved) {\n                return _this.service.resolveSchemaContent(unresolved, _this.url, _this.dependencies);\n            });\n        }\n        return this.resolvedSchema;\n    };\n    SchemaHandle.prototype.clearSchema = function () {\n        this.resolvedSchema = null;\n        this.unresolvedSchema = null;\n        this.dependencies = {};\n    };\n    return SchemaHandle;\n}());\nvar UnresolvedSchema = /** @class */ (function () {\n    function UnresolvedSchema(schema, errors) {\n        if (errors === void 0) { errors = []; }\n        this.schema = schema;\n        this.errors = errors;\n    }\n    return UnresolvedSchema;\n}());\nexport { UnresolvedSchema };\nvar ResolvedSchema = /** @class */ (function () {\n    function ResolvedSchema(schema, errors) {\n        if (errors === void 0) { errors = []; }\n        this.schema = schema;\n        this.errors = errors;\n    }\n    ResolvedSchema.prototype.getSection = function (path) {\n        return Parser.asSchema(this.getSectionRecursive(path, this.schema));\n    };\n    ResolvedSchema.prototype.getSectionRecursive = function (path, schema) {\n        if (!schema || typeof schema === 'boolean' || path.length === 0) {\n            return schema;\n        }\n        var next = path.shift();\n        if (schema.properties && typeof schema.properties[next]) {\n            return this.getSectionRecursive(path, schema.properties[next]);\n        }\n        else if (schema.patternProperties) {\n            for (var _i = 0, _a = Object.keys(schema.patternProperties); _i < _a.length; _i++) {\n                var pattern = _a[_i];\n                var regex = new RegExp(pattern);\n                if (regex.test(next)) {\n                    return this.getSectionRecursive(path, schema.patternProperties[pattern]);\n                }\n            }\n        }\n        else if (typeof schema.additionalProperties === 'object') {\n            return this.getSectionRecursive(path, schema.additionalProperties);\n        }\n        else if (next.match('[0-9]+')) {\n            if (Array.isArray(schema.items)) {\n                var index = parseInt(next, 10);\n                if (!isNaN(index) && schema.items[index]) {\n                    return this.getSectionRecursive(path, schema.items[index]);\n                }\n            }\n            else if (schema.items) {\n                return this.getSectionRecursive(path, schema.items);\n            }\n        }\n        return null;\n    };\n    return ResolvedSchema;\n}());\nexport { ResolvedSchema };\nvar JSONSchemaService = /** @class */ (function () {\n    function JSONSchemaService(requestService, contextService, promiseConstructor) {\n        this.contextService = contextService;\n        this.requestService = requestService;\n        this.promiseConstructor = promiseConstructor || Promise;\n        this.callOnDispose = [];\n        this.contributionSchemas = {};\n        this.contributionAssociations = {};\n        this.schemasById = {};\n        this.filePatternAssociations = [];\n        this.filePatternAssociationById = {};\n        this.registeredSchemasIds = {};\n    }\n    JSONSchemaService.prototype.getRegisteredSchemaIds = function (filter) {\n        return Object.keys(this.registeredSchemasIds).filter(function (id) {\n            var scheme = URI.parse(id).scheme;\n            return scheme !== 'schemaservice' && (!filter || filter(scheme));\n        });\n    };\n    Object.defineProperty(JSONSchemaService.prototype, \"promise\", {\n        get: function () {\n            return this.promiseConstructor;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    JSONSchemaService.prototype.dispose = function () {\n        while (this.callOnDispose.length > 0) {\n            this.callOnDispose.pop()();\n        }\n    };\n    JSONSchemaService.prototype.onResourceChange = function (uri) {\n        var _this = this;\n        var hasChanges = false;\n        uri = this.normalizeId(uri);\n        var toWalk = [uri];\n        var all = Object.keys(this.schemasById).map(function (key) { return _this.schemasById[key]; });\n        while (toWalk.length) {\n            var curr = toWalk.pop();\n            for (var i = 0; i < all.length; i++) {\n                var handle = all[i];\n                if (handle && (handle.url === curr || handle.dependencies[curr])) {\n                    if (handle.url !== curr) {\n                        toWalk.push(handle.url);\n                    }\n                    handle.clearSchema();\n                    all[i] = undefined;\n                    hasChanges = true;\n                }\n            }\n        }\n        return hasChanges;\n    };\n    JSONSchemaService.prototype.normalizeId = function (id) {\n        // remove trailing '#', normalize drive capitalization\n        return URI.parse(id).toString();\n    };\n    JSONSchemaService.prototype.setSchemaContributions = function (schemaContributions) {\n        if (schemaContributions.schemas) {\n            var schemas = schemaContributions.schemas;\n            for (var id in schemas) {\n                var normalizedId = this.normalizeId(id);\n                this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas[id]);\n            }\n        }\n        if (schemaContributions.schemaAssociations) {\n            var schemaAssociations = schemaContributions.schemaAssociations;\n            for (var pattern in schemaAssociations) {\n                var associations = schemaAssociations[pattern];\n                this.contributionAssociations[pattern] = associations;\n                var fpa = this.getOrAddFilePatternAssociation(pattern);\n                for (var _i = 0, associations_1 = associations; _i < associations_1.length; _i++) {\n                    var schemaId = associations_1[_i];\n                    var id = this.normalizeId(schemaId);\n                    fpa.addSchema(id);\n                }\n            }\n        }\n    };\n    JSONSchemaService.prototype.addSchemaHandle = function (id, unresolvedSchemaContent) {\n        var schemaHandle = new SchemaHandle(this, id, unresolvedSchemaContent);\n        this.schemasById[id] = schemaHandle;\n        return schemaHandle;\n    };\n    JSONSchemaService.prototype.getOrAddSchemaHandle = function (id, unresolvedSchemaContent) {\n        return this.schemasById[id] || this.addSchemaHandle(id, unresolvedSchemaContent);\n    };\n    JSONSchemaService.prototype.getOrAddFilePatternAssociation = function (pattern) {\n        var fpa = this.filePatternAssociationById[pattern];\n        if (!fpa) {\n            fpa = new FilePatternAssociation(pattern);\n            this.filePatternAssociationById[pattern] = fpa;\n            this.filePatternAssociations.push(fpa);\n        }\n        return fpa;\n    };\n    JSONSchemaService.prototype.registerExternalSchema = function (uri, filePatterns, unresolvedSchemaContent) {\n        if (filePatterns === void 0) { filePatterns = null; }\n        var id = this.normalizeId(uri);\n        this.registeredSchemasIds[id] = true;\n        if (filePatterns) {\n            for (var _i = 0, filePatterns_1 = filePatterns; _i < filePatterns_1.length; _i++) {\n                var pattern = filePatterns_1[_i];\n                this.getOrAddFilePatternAssociation(pattern).addSchema(id);\n            }\n        }\n        return unresolvedSchemaContent ? this.addSchemaHandle(id, unresolvedSchemaContent) : this.getOrAddSchemaHandle(id);\n    };\n    JSONSchemaService.prototype.clearExternalSchemas = function () {\n        this.schemasById = {};\n        this.filePatternAssociations = [];\n        this.filePatternAssociationById = {};\n        this.registeredSchemasIds = {};\n        for (var id in this.contributionSchemas) {\n            this.schemasById[id] = this.contributionSchemas[id];\n            this.registeredSchemasIds[id] = true;\n        }\n        for (var pattern in this.contributionAssociations) {\n            var fpa = this.getOrAddFilePatternAssociation(pattern);\n            for (var _i = 0, _a = this.contributionAssociations[pattern]; _i < _a.length; _i++) {\n                var schemaId = _a[_i];\n                var id = this.normalizeId(schemaId);\n                fpa.addSchema(id);\n            }\n        }\n    };\n    JSONSchemaService.prototype.getResolvedSchema = function (schemaId) {\n        var id = this.normalizeId(schemaId);\n        var schemaHandle = this.schemasById[id];\n        if (schemaHandle) {\n            return schemaHandle.getResolvedSchema();\n        }\n        return this.promise.resolve(null);\n    };\n    JSONSchemaService.prototype.loadSchema = function (url) {\n        if (!this.requestService) {\n            var errorMessage = localize('json.schema.norequestservice', 'Unable to load schema from \\'{0}\\'. No schema request service available', toDisplayString(url));\n            return this.promise.resolve(new UnresolvedSchema({}, [errorMessage]));\n        }\n        return this.requestService(url).then(function (content) {\n            if (!content) {\n                var errorMessage = localize('json.schema.nocontent', 'Unable to load schema from \\'{0}\\': No content.', toDisplayString(url));\n                return new UnresolvedSchema({}, [errorMessage]);\n            }\n            var schemaContent = {};\n            var jsonErrors = [];\n            schemaContent = Json.parse(content, jsonErrors);\n            var errors = jsonErrors.length ? [localize('json.schema.invalidFormat', 'Unable to parse content from \\'{0}\\': Parse error at offset {1}.', toDisplayString(url), jsonErrors[0].offset)] : [];\n            return new UnresolvedSchema(schemaContent, errors);\n        }, function (error) {\n            var errorMessage = error.toString();\n            var errorSplit = error.toString().split('Error: ');\n            if (errorSplit.length > 1) {\n                // more concise error message, URL and context are attached by caller anyways\n                errorMessage = errorSplit[1];\n            }\n            return new UnresolvedSchema({}, [errorMessage]);\n        });\n    };\n    JSONSchemaService.prototype.resolveSchemaContent = function (schemaToResolve, schemaURL, dependencies) {\n        var _this = this;\n        var resolveErrors = schemaToResolve.errors.slice(0);\n        var schema = schemaToResolve.schema;\n        var contextService = this.contextService;\n        var findSection = function (schema, path) {\n            if (!path) {\n                return schema;\n            }\n            var current = schema;\n            if (path[0] === '/') {\n                path = path.substr(1);\n            }\n            path.split('/').some(function (part) {\n                current = current[part];\n                return !current;\n            });\n            return current;\n        };\n        var merge = function (target, sourceRoot, sourceURI, path) {\n            var section = findSection(sourceRoot, path);\n            if (section) {\n                for (var key in section) {\n                    if (section.hasOwnProperty(key) && !target.hasOwnProperty(key)) {\n                        target[key] = section[key];\n                    }\n                }\n            }\n            else {\n                resolveErrors.push(localize('json.schema.invalidref', '$ref \\'{0}\\' in \\'{1}\\' can not be resolved.', path, sourceURI));\n            }\n        };\n        var resolveExternalLink = function (node, uri, linkPath, parentSchemaURL, parentSchemaDependencies) {\n            if (contextService && !/^\\w+:\\/\\/.*/.test(uri)) {\n                uri = contextService.resolveRelativePath(uri, parentSchemaURL);\n            }\n            uri = _this.normalizeId(uri);\n            var referencedHandle = _this.getOrAddSchemaHandle(uri);\n            return referencedHandle.getUnresolvedSchema().then(function (unresolvedSchema) {\n                parentSchemaDependencies[uri] = true;\n                if (unresolvedSchema.errors.length) {\n                    var loc = linkPath ? uri + '#' + linkPath : uri;\n                    resolveErrors.push(localize('json.schema.problemloadingref', 'Problems loading reference \\'{0}\\': {1}', loc, unresolvedSchema.errors[0]));\n                }\n                merge(node, unresolvedSchema.schema, uri, linkPath);\n                return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);\n            });\n        };\n        var resolveRefs = function (node, parentSchema, parentSchemaURL, parentSchemaDependencies) {\n            if (!node || typeof node !== 'object') {\n                return Promise.resolve(null);\n            }\n            var toWalk = [node];\n            var seen = [];\n            var openPromises = [];\n            var collectEntries = function () {\n                var entries = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    entries[_i] = arguments[_i];\n                }\n                for (var _a = 0, entries_1 = entries; _a < entries_1.length; _a++) {\n                    var entry = entries_1[_a];\n                    if (typeof entry === 'object') {\n                        toWalk.push(entry);\n                    }\n                }\n            };\n            var collectMapEntries = function () {\n                var maps = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    maps[_i] = arguments[_i];\n                }\n                for (var _a = 0, maps_1 = maps; _a < maps_1.length; _a++) {\n                    var map = maps_1[_a];\n                    if (typeof map === 'object') {\n                        for (var key in map) {\n                            var entry = map[key];\n                            if (typeof entry === 'object') {\n                                toWalk.push(entry);\n                            }\n                        }\n                    }\n                }\n            };\n            var collectArrayEntries = function () {\n                var arrays = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    arrays[_i] = arguments[_i];\n                }\n                for (var _a = 0, arrays_1 = arrays; _a < arrays_1.length; _a++) {\n                    var array = arrays_1[_a];\n                    if (Array.isArray(array)) {\n                        for (var _b = 0, array_1 = array; _b < array_1.length; _b++) {\n                            var entry = array_1[_b];\n                            if (typeof entry === 'object') {\n                                toWalk.push(entry);\n                            }\n                        }\n                    }\n                }\n            };\n            var handleRef = function (next) {\n                var seenRefs = [];\n                while (next.$ref) {\n                    var ref = next.$ref;\n                    var segments = ref.split('#', 2);\n                    delete next.$ref;\n                    if (segments[0].length > 0) {\n                        openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));\n                        return;\n                    }\n                    else {\n                        if (seenRefs.indexOf(ref) === -1) {\n                            merge(next, parentSchema, parentSchemaURL, segments[1]); // can set next.$ref again, use seenRefs to avoid circle\n                            seenRefs.push(ref);\n                        }\n                    }\n                }\n                collectEntries(next.items, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else);\n                collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);\n                collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items);\n            };\n            while (toWalk.length) {\n                var next = toWalk.pop();\n                if (seen.indexOf(next) >= 0) {\n                    continue;\n                }\n                seen.push(next);\n                handleRef(next);\n            }\n            return _this.promise.all(openPromises);\n        };\n        return resolveRefs(schema, schema, schemaURL, dependencies).then(function (_) { return new ResolvedSchema(schema, resolveErrors); });\n    };\n    JSONSchemaService.prototype.getSchemaForResource = function (resource, document) {\n        // first use $schema if present\n        if (document && document.root && document.root.type === 'object') {\n            var schemaProperties = document.root.properties.filter(function (p) { return (p.keyNode.value === '$schema') && p.valueNode && p.valueNode.type === 'string'; });\n            if (schemaProperties.length > 0) {\n                var schemeId = Parser.getNodeValue(schemaProperties[0].valueNode);\n                if (schemeId && Strings.startsWith(schemeId, '.') && this.contextService) {\n                    schemeId = this.contextService.resolveRelativePath(schemeId, resource);\n                }\n                if (schemeId) {\n                    var id = this.normalizeId(schemeId);\n                    return this.getOrAddSchemaHandle(id).getResolvedSchema();\n                }\n            }\n        }\n        var seen = Object.create(null);\n        var schemas = [];\n        for (var _i = 0, _a = this.filePatternAssociations; _i < _a.length; _i++) {\n            var entry = _a[_i];\n            if (entry.matchesPattern(resource)) {\n                for (var _b = 0, _c = entry.getSchemas(); _b < _c.length; _b++) {\n                    var schemaId = _c[_b];\n                    if (!seen[schemaId]) {\n                        schemas.push(schemaId);\n                        seen[schemaId] = true;\n                    }\n                }\n            }\n        }\n        if (schemas.length > 0) {\n            return this.createCombinedSchema(resource, schemas).getResolvedSchema();\n        }\n        return this.promise.resolve(null);\n    };\n    JSONSchemaService.prototype.createCombinedSchema = function (resource, schemaIds) {\n        if (schemaIds.length === 1) {\n            return this.getOrAddSchemaHandle(schemaIds[0]);\n        }\n        else {\n            var combinedSchemaId = 'schemaservice://combinedSchema/' + encodeURIComponent(resource);\n            var combinedSchema = {\n                allOf: schemaIds.map(function (schemaId) { return ({ $ref: schemaId }); })\n            };\n            return this.addSchemaHandle(combinedSchemaId, combinedSchema);\n        }\n    };\n    return JSONSchemaService;\n}());\nexport { JSONSchemaService };\nfunction toDisplayString(url) {\n    try {\n        var uri = URI.parse(url);\n        if (uri.scheme === 'file') {\n            return uri.fsPath;\n        }\n    }\n    catch (e) {\n        // ignore\n    }\n    return url;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { UnresolvedSchema } from './jsonSchemaService.js';\nimport { Diagnostic, DiagnosticSeverity, Range } from '../../vscode-languageserver-types/main.js';\nimport { ErrorCode } from '../jsonLanguageTypes.js';\nimport * as nls from '../../../fillers/vscode-nls.js';\nvar localize = nls.loadMessageBundle();\nvar JSONValidation = /** @class */ (function () {\n    function JSONValidation(jsonSchemaService, promiseConstructor) {\n        this.jsonSchemaService = jsonSchemaService;\n        this.promise = promiseConstructor;\n        this.validationEnabled = true;\n    }\n    JSONValidation.prototype.configure = function (raw) {\n        if (raw) {\n            this.validationEnabled = raw.validate;\n            this.commentSeverity = raw.allowComments ? void 0 : DiagnosticSeverity.Error;\n        }\n    };\n    JSONValidation.prototype.doValidation = function (textDocument, jsonDocument, documentSettings, schema) {\n        var _this = this;\n        if (!this.validationEnabled) {\n            return this.promise.resolve([]);\n        }\n        var diagnostics = [];\n        var added = {};\n        var addProblem = function (problem) {\n            // remove duplicated messages\n            var signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;\n            if (!added[signature]) {\n                added[signature] = true;\n                diagnostics.push(problem);\n            }\n        };\n        var getDiagnostics = function (schema) {\n            var trailingCommaSeverity = documentSettings ? toDiagnosticSeverity(documentSettings.trailingCommas) : DiagnosticSeverity.Error;\n            var commentSeverity = documentSettings ? toDiagnosticSeverity(documentSettings.comments) : _this.commentSeverity;\n            if (schema) {\n                if (schema.errors.length && jsonDocument.root) {\n                    var astRoot = jsonDocument.root;\n                    var property = astRoot.type === 'object' ? astRoot.properties[0] : null;\n                    if (property && property.keyNode.value === '$schema') {\n                        var node = property.valueNode || property;\n                        var range = Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));\n                        addProblem(Diagnostic.create(range, schema.errors[0], DiagnosticSeverity.Warning, ErrorCode.SchemaResolveError));\n                    }\n                    else {\n                        var range = Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));\n                        addProblem(Diagnostic.create(range, schema.errors[0], DiagnosticSeverity.Warning, ErrorCode.SchemaResolveError));\n                    }\n                }\n                else {\n                    var semanticErrors = jsonDocument.validate(textDocument, schema.schema);\n                    if (semanticErrors) {\n                        semanticErrors.forEach(addProblem);\n                    }\n                }\n                if (schemaAllowsComments(schema.schema)) {\n                    trailingCommaSeverity = commentSeverity = void 0;\n                }\n            }\n            for (var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++) {\n                var p = _a[_i];\n                if (p.code === ErrorCode.TrailingComma) {\n                    if (typeof trailingCommaSeverity !== 'number') {\n                        continue;\n                    }\n                    p.severity = trailingCommaSeverity;\n                }\n                addProblem(p);\n            }\n            if (typeof commentSeverity === 'number') {\n                var message_1 = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');\n                jsonDocument.comments.forEach(function (c) {\n                    addProblem(Diagnostic.create(c, message_1, commentSeverity, ErrorCode.CommentNotPermitted));\n                });\n            }\n            return diagnostics;\n        };\n        if (schema) {\n            var id = schema.id || ('schemaservice://untitled/' + idCounter++);\n            return this.jsonSchemaService.resolveSchemaContent(new UnresolvedSchema(schema), id, {}).then(function (resolvedSchema) {\n                return getDiagnostics(resolvedSchema);\n            });\n        }\n        return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function (schema) {\n            return getDiagnostics(schema);\n        });\n    };\n    return JSONValidation;\n}());\nexport { JSONValidation };\nvar idCounter = 0;\nfunction schemaAllowsComments(schemaRef) {\n    if (schemaRef && typeof schemaRef === 'object') {\n        if (schemaRef.allowComments) {\n            return true;\n        }\n        if (schemaRef.allOf) {\n            return schemaRef.allOf.some(schemaAllowsComments);\n        }\n    }\n    return false;\n}\nfunction toDiagnosticSeverity(severityLevel) {\n    switch (severityLevel) {\n        case 'error': return DiagnosticSeverity.Error;\n        case 'warning': return DiagnosticSeverity.Warning;\n        case 'ignore': return void 0;\n    }\n    return void 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar Digit0 = 48;\nvar Digit9 = 57;\nvar A = 65;\nvar a = 97;\nvar f = 102;\nexport function hexDigit(charCode) {\n    if (charCode < Digit0) {\n        return 0;\n    }\n    if (charCode <= Digit9) {\n        return charCode - Digit0;\n    }\n    if (charCode < a) {\n        charCode += (a - A);\n    }\n    if (charCode >= a && charCode <= f) {\n        return charCode - a + 10;\n    }\n    return 0;\n}\nexport function colorFromHex(text) {\n    if (text[0] !== '#') {\n        return null;\n    }\n    switch (text.length) {\n        case 4:\n            return {\n                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,\n                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,\n                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,\n                alpha: 1\n            };\n        case 5:\n            return {\n                red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,\n                green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,\n                blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,\n                alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,\n            };\n        case 7:\n            return {\n                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,\n                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,\n                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,\n                alpha: 1\n            };\n        case 9:\n            return {\n                red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,\n                green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,\n                blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,\n                alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0\n            };\n    }\n    return null;\n}\nexport function colorFrom256RGB(red, green, blue, alpha) {\n    if (alpha === void 0) { alpha = 1.0; }\n    return {\n        red: red / 255.0,\n        green: green / 255.0,\n        blue: blue / 255.0,\n        alpha: alpha\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as Parser from '../parser/jsonParser.js';\nimport * as Strings from '../utils/strings.js';\nimport { colorFromHex } from '../utils/colors.js';\nimport { SymbolKind, Range, Location, TextEdit } from '../../vscode-languageserver-types/main.js';\nvar JSONDocumentSymbols = /** @class */ (function () {\n    function JSONDocumentSymbols(schemaService) {\n        this.schemaService = schemaService;\n    }\n    JSONDocumentSymbols.prototype.findDocumentSymbols = function (document, doc) {\n        var _this = this;\n        var root = doc.root;\n        if (!root) {\n            return null;\n        }\n        // special handling for key bindings\n        var resourceString = document.uri;\n        if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {\n            if (root.type === 'array') {\n                var result_1 = [];\n                root.items.forEach(function (item) {\n                    if (item.type === 'object') {\n                        for (var _i = 0, _a = item.properties; _i < _a.length; _i++) {\n                            var property = _a[_i];\n                            if (property.keyNode.value === 'key') {\n                                if (property.valueNode) {\n                                    if (property.valueNode) {\n                                        var location = Location.create(document.uri, getRange(document, item));\n                                        result_1.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, location: location });\n                                    }\n                                    return;\n                                }\n                            }\n                        }\n                    }\n                });\n                return result_1;\n            }\n        }\n        var collectOutlineEntries = function (result, node, containerName) {\n            if (node.type === 'array') {\n                node.items.forEach(function (node) { return collectOutlineEntries(result, node, containerName); });\n            }\n            else if (node.type === 'object') {\n                node.properties.forEach(function (property) {\n                    var location = Location.create(document.uri, getRange(document, property));\n                    var valueNode = property.valueNode;\n                    if (valueNode) {\n                        var childContainerName = containerName ? containerName + '.' + property.keyNode.value : property.keyNode.value;\n                        result.push({ name: _this.getKeyLabel(property), kind: _this.getSymbolKind(valueNode.type), location: location, containerName: containerName });\n                        collectOutlineEntries(result, valueNode, childContainerName);\n                    }\n                });\n            }\n            return result;\n        };\n        var result = collectOutlineEntries([], root, void 0);\n        return result;\n    };\n    JSONDocumentSymbols.prototype.findDocumentSymbols2 = function (document, doc) {\n        var _this = this;\n        var root = doc.root;\n        if (!root) {\n            return null;\n        }\n        // special handling for key bindings\n        var resourceString = document.uri;\n        if ((resourceString === 'vscode://defaultsettings/keybindings.json') || Strings.endsWith(resourceString.toLowerCase(), '/user/keybindings.json')) {\n            if (root.type === 'array') {\n                var result_2 = [];\n                root.items.forEach(function (item) {\n                    if (item.type === 'object') {\n                        for (var _i = 0, _a = item.properties; _i < _a.length; _i++) {\n                            var property = _a[_i];\n                            if (property.keyNode.value === 'key') {\n                                if (property.valueNode) {\n                                    var range = getRange(document, item);\n                                    var selectionRange = getRange(document, property.keyNode);\n                                    result_2.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, range: range, selectionRange: selectionRange });\n                                }\n                                return;\n                            }\n                        }\n                    }\n                });\n                return result_2;\n            }\n        }\n        var collectOutlineEntries = function (result, node) {\n            if (node.type === 'array') {\n                node.items.forEach(function (node, index) {\n                    if (node) {\n                        var range = getRange(document, node);\n                        var selectionRange = range;\n                        var name = String(index);\n                        var children = collectOutlineEntries([], node);\n                        result.push({ name: name, kind: _this.getSymbolKind(node.type), range: range, selectionRange: selectionRange, children: children });\n                    }\n                });\n            }\n            else if (node.type === 'object') {\n                node.properties.forEach(function (property) {\n                    var valueNode = property.valueNode;\n                    if (valueNode) {\n                        var range = getRange(document, property);\n                        var selectionRange = getRange(document, property.keyNode);\n                        var children = collectOutlineEntries([], valueNode);\n                        result.push({ name: _this.getKeyLabel(property), kind: _this.getSymbolKind(valueNode.type), range: range, selectionRange: selectionRange, children: children });\n                    }\n                });\n            }\n            return result;\n        };\n        var result = collectOutlineEntries([], root);\n        return result;\n    };\n    JSONDocumentSymbols.prototype.getSymbolKind = function (nodeType) {\n        switch (nodeType) {\n            case 'object':\n                return SymbolKind.Module;\n            case 'string':\n                return SymbolKind.String;\n            case 'number':\n                return SymbolKind.Number;\n            case 'array':\n                return SymbolKind.Array;\n            case 'boolean':\n                return SymbolKind.Boolean;\n            default: // 'null'\n                return SymbolKind.Variable;\n        }\n    };\n    JSONDocumentSymbols.prototype.getKeyLabel = function (property) {\n        var name = property.keyNode.value;\n        if (name) {\n            name = name.replace(/[\\n]/g, '↵');\n        }\n        if (name && name.trim()) {\n            return name;\n        }\n        return \"\\\"\" + name + \"\\\"\";\n    };\n    JSONDocumentSymbols.prototype.findDocumentColors = function (document, doc) {\n        return this.schemaService.getSchemaForResource(document.uri, doc).then(function (schema) {\n            var result = [];\n            if (schema) {\n                var matchingSchemas = doc.getMatchingSchemas(schema.schema);\n                var visitedNode = {};\n                for (var _i = 0, matchingSchemas_1 = matchingSchemas; _i < matchingSchemas_1.length; _i++) {\n                    var s = matchingSchemas_1[_i];\n                    if (!s.inverted && s.schema && (s.schema.format === 'color' || s.schema.format === 'color-hex') && s.node && s.node.type === 'string') {\n                        var nodeId = String(s.node.offset);\n                        if (!visitedNode[nodeId]) {\n                            var color = colorFromHex(Parser.getNodeValue(s.node));\n                            if (color) {\n                                var range = getRange(document, s.node);\n                                result.push({ color: color, range: range });\n                            }\n                            visitedNode[nodeId] = true;\n                        }\n                    }\n                }\n            }\n            return result;\n        });\n    };\n    JSONDocumentSymbols.prototype.getColorPresentations = function (document, doc, color, range) {\n        var result = [];\n        var red256 = Math.round(color.red * 255), green256 = Math.round(color.green * 255), blue256 = Math.round(color.blue * 255);\n        function toTwoDigitHex(n) {\n            var r = n.toString(16);\n            return r.length !== 2 ? '0' + r : r;\n        }\n        var label;\n        if (color.alpha === 1) {\n            label = \"#\" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256);\n        }\n        else {\n            label = \"#\" + toTwoDigitHex(red256) + toTwoDigitHex(green256) + toTwoDigitHex(blue256) + toTwoDigitHex(Math.round(color.alpha * 255));\n        }\n        result.push({ label: label, textEdit: TextEdit.replace(range, JSON.stringify(label)) });\n        return result;\n    };\n    return JSONDocumentSymbols;\n}());\nexport { JSONDocumentSymbols };\nfunction getRange(document, node) {\n    return Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as nls from '../../../fillers/vscode-nls.js';\nvar localize = nls.loadMessageBundle();\nexport var schemaContributions = {\n    schemaAssociations: {},\n    schemas: {\n        // bundle the schema-schema to include (localized) descriptions\n        'http://json-schema.org/draft-04/schema#': {\n            'title': localize('schema.json', 'Describes a JSON file using a schema. See json-schema.org for more info.'),\n            '$schema': 'http://json-schema.org/draft-04/schema#',\n            'definitions': {\n                'schemaArray': {\n                    'type': 'array',\n                    'minItems': 1,\n                    'items': {\n                        '$ref': '#'\n                    }\n                },\n                'positiveInteger': {\n                    'type': 'integer',\n                    'minimum': 0\n                },\n                'positiveIntegerDefault0': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveInteger'\n                        },\n                        {\n                            'default': 0\n                        }\n                    ]\n                },\n                'simpleTypes': {\n                    'type': 'string',\n                    'enum': [\n                        'array',\n                        'boolean',\n                        'integer',\n                        'null',\n                        'number',\n                        'object',\n                        'string'\n                    ]\n                },\n                'stringArray': {\n                    'type': 'array',\n                    'items': {\n                        'type': 'string'\n                    },\n                    'minItems': 1,\n                    'uniqueItems': true\n                }\n            },\n            'type': 'object',\n            'properties': {\n                'id': {\n                    'type': 'string',\n                    'format': 'uri'\n                },\n                '$schema': {\n                    'type': 'string',\n                    'format': 'uri'\n                },\n                'title': {\n                    'type': 'string'\n                },\n                'description': {\n                    'type': 'string'\n                },\n                'default': {},\n                'multipleOf': {\n                    'type': 'number',\n                    'minimum': 0,\n                    'exclusiveMinimum': true\n                },\n                'maximum': {\n                    'type': 'number'\n                },\n                'exclusiveMaximum': {\n                    'type': 'boolean',\n                    'default': false\n                },\n                'minimum': {\n                    'type': 'number'\n                },\n                'exclusiveMinimum': {\n                    'type': 'boolean',\n                    'default': false\n                },\n                'maxLength': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveInteger'\n                        }\n                    ]\n                },\n                'minLength': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveIntegerDefault0'\n                        }\n                    ]\n                },\n                'pattern': {\n                    'type': 'string',\n                    'format': 'regex'\n                },\n                'additionalItems': {\n                    'anyOf': [\n                        {\n                            'type': 'boolean'\n                        },\n                        {\n                            '$ref': '#'\n                        }\n                    ],\n                    'default': {}\n                },\n                'items': {\n                    'anyOf': [\n                        {\n                            '$ref': '#'\n                        },\n                        {\n                            '$ref': '#/definitions/schemaArray'\n                        }\n                    ],\n                    'default': {}\n                },\n                'maxItems': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveInteger'\n                        }\n                    ]\n                },\n                'minItems': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveIntegerDefault0'\n                        }\n                    ]\n                },\n                'uniqueItems': {\n                    'type': 'boolean',\n                    'default': false\n                },\n                'maxProperties': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveInteger'\n                        }\n                    ]\n                },\n                'minProperties': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/positiveIntegerDefault0'\n                        }\n                    ]\n                },\n                'required': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/stringArray'\n                        }\n                    ]\n                },\n                'additionalProperties': {\n                    'anyOf': [\n                        {\n                            'type': 'boolean'\n                        },\n                        {\n                            '$ref': '#'\n                        }\n                    ],\n                    'default': {}\n                },\n                'definitions': {\n                    'type': 'object',\n                    'additionalProperties': {\n                        '$ref': '#'\n                    },\n                    'default': {}\n                },\n                'properties': {\n                    'type': 'object',\n                    'additionalProperties': {\n                        '$ref': '#'\n                    },\n                    'default': {}\n                },\n                'patternProperties': {\n                    'type': 'object',\n                    'additionalProperties': {\n                        '$ref': '#'\n                    },\n                    'default': {}\n                },\n                'dependencies': {\n                    'type': 'object',\n                    'additionalProperties': {\n                        'anyOf': [\n                            {\n                                '$ref': '#'\n                            },\n                            {\n                                '$ref': '#/definitions/stringArray'\n                            }\n                        ]\n                    }\n                },\n                'enum': {\n                    'type': 'array',\n                    'minItems': 1,\n                    'uniqueItems': true\n                },\n                'type': {\n                    'anyOf': [\n                        {\n                            '$ref': '#/definitions/simpleTypes'\n                        },\n                        {\n                            'type': 'array',\n                            'items': {\n                                '$ref': '#/definitions/simpleTypes'\n                            },\n                            'minItems': 1,\n                            'uniqueItems': true\n                        }\n                    ]\n                },\n                'format': {\n                    'anyOf': [\n                        {\n                            'type': 'string',\n                            'enum': [\n                                'date-time',\n                                'uri',\n                                'email',\n                                'hostname',\n                                'ipv4',\n                                'ipv6',\n                                'regex'\n                            ]\n                        },\n                        {\n                            'type': 'string'\n                        }\n                    ]\n                },\n                'allOf': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/schemaArray'\n                        }\n                    ]\n                },\n                'anyOf': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/schemaArray'\n                        }\n                    ]\n                },\n                'oneOf': {\n                    'allOf': [\n                        {\n                            '$ref': '#/definitions/schemaArray'\n                        }\n                    ]\n                },\n                'not': {\n                    'allOf': [\n                        {\n                            '$ref': '#'\n                        }\n                    ]\n                }\n            },\n            'dependencies': {\n                'exclusiveMaximum': [\n                    'maximum'\n                ],\n                'exclusiveMinimum': [\n                    'minimum'\n                ]\n            },\n            'default': {}\n        },\n        'http://json-schema.org/draft-07/schema#': {\n            'title': localize('schema.json', 'Describes a JSON file using a schema. See json-schema.org for more info.'),\n            'definitions': {\n                'schemaArray': {\n                    'type': 'array',\n                    'minItems': 1,\n                    'items': { '$ref': '#' }\n                },\n                'nonNegativeInteger': {\n                    'type': 'integer',\n                    'minimum': 0\n                },\n                'nonNegativeIntegerDefault0': {\n                    'allOf': [\n                        { '$ref': '#/definitions/nonNegativeInteger' },\n                        { 'default': 0 }\n                    ]\n                },\n                'simpleTypes': {\n                    'enum': [\n                        'array',\n                        'boolean',\n                        'integer',\n                        'null',\n                        'number',\n                        'object',\n                        'string'\n                    ]\n                },\n                'stringArray': {\n                    'type': 'array',\n                    'items': { 'type': 'string' },\n                    'uniqueItems': true,\n                    'default': []\n                }\n            },\n            'type': ['object', 'boolean'],\n            'properties': {\n                '$id': {\n                    'type': 'string',\n                    'format': 'uri-reference'\n                },\n                '$schema': {\n                    'type': 'string',\n                    'format': 'uri'\n                },\n                '$ref': {\n                    'type': 'string',\n                    'format': 'uri-reference'\n                },\n                '$comment': {\n                    'type': 'string'\n                },\n                'title': {\n                    'type': 'string'\n                },\n                'description': {\n                    'type': 'string'\n                },\n                'default': true,\n                'readOnly': {\n                    'type': 'boolean',\n                    'default': false\n                },\n                'examples': {\n                    'type': 'array',\n                    'items': true\n                },\n                'multipleOf': {\n                    'type': 'number',\n                    'exclusiveMinimum': 0\n                },\n                'maximum': {\n                    'type': 'number'\n                },\n                'exclusiveMaximum': {\n                    'type': 'number'\n                },\n                'minimum': {\n                    'type': 'number'\n                },\n                'exclusiveMinimum': {\n                    'type': 'number'\n                },\n                'maxLength': { '$ref': '#/definitions/nonNegativeInteger' },\n                'minLength': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },\n                'pattern': {\n                    'type': 'string',\n                    'format': 'regex'\n                },\n                'additionalItems': { '$ref': '#' },\n                'items': {\n                    'anyOf': [\n                        { '$ref': '#' },\n                        { '$ref': '#/definitions/schemaArray' }\n                    ],\n                    'default': true\n                },\n                'maxItems': { '$ref': '#/definitions/nonNegativeInteger' },\n                'minItems': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },\n                'uniqueItems': {\n                    'type': 'boolean',\n                    'default': false\n                },\n                'contains': { '$ref': '#' },\n                'maxProperties': { '$ref': '#/definitions/nonNegativeInteger' },\n                'minProperties': { '$ref': '#/definitions/nonNegativeIntegerDefault0' },\n                'required': { '$ref': '#/definitions/stringArray' },\n                'additionalProperties': { '$ref': '#' },\n                'definitions': {\n                    'type': 'object',\n                    'additionalProperties': { '$ref': '#' },\n                    'default': {}\n                },\n                'properties': {\n                    'type': 'object',\n                    'additionalProperties': { '$ref': '#' },\n                    'default': {}\n                },\n                'patternProperties': {\n                    'type': 'object',\n                    'additionalProperties': { '$ref': '#' },\n                    'propertyNames': { 'format': 'regex' },\n                    'default': {}\n                },\n                'dependencies': {\n                    'type': 'object',\n                    'additionalProperties': {\n                        'anyOf': [\n                            { '$ref': '#' },\n                            { '$ref': '#/definitions/stringArray' }\n                        ]\n                    }\n                },\n                'propertyNames': { '$ref': '#' },\n                'const': true,\n                'enum': {\n                    'type': 'array',\n                    'items': true,\n                    'minItems': 1,\n                    'uniqueItems': true\n                },\n                'type': {\n                    'anyOf': [\n                        { '$ref': '#/definitions/simpleTypes' },\n                        {\n                            'type': 'array',\n                            'items': { '$ref': '#/definitions/simpleTypes' },\n                            'minItems': 1,\n                            'uniqueItems': true\n                        }\n                    ]\n                },\n                'format': { 'type': 'string' },\n                'contentMediaType': { 'type': 'string' },\n                'contentEncoding': { 'type': 'string' },\n                'if': { '$ref': '#' },\n                'then': { '$ref': '#' },\n                'else': { '$ref': '#' },\n                'allOf': { '$ref': '#/definitions/schemaArray' },\n                'anyOf': { '$ref': '#/definitions/schemaArray' },\n                'oneOf': { '$ref': '#/definitions/schemaArray' },\n                'not': { '$ref': '#' }\n            },\n            'default': true\n        }\n    }\n};\nvar descriptions = {\n    id: localize('schema.json.id', \"A unique identifier for the schema.\"),\n    $schema: localize('schema.json.$schema', \"The schema to verify this document against.\"),\n    title: localize('schema.json.title', \"A descriptive title of the element.\"),\n    description: localize('schema.json.description', \"A long description of the element. Used in hover menus and suggestions.\"),\n    default: localize('schema.json.default', \"A default value. Used by suggestions.\"),\n    multipleOf: localize('schema.json.multipleOf', \"A number that should cleanly divide the current value (i.e. have no remainder).\"),\n    maximum: localize('schema.json.maximum', \"The maximum numerical value, inclusive by default.\"),\n    exclusiveMaximum: localize('schema.json.exclusiveMaximum', \"Makes the maximum property exclusive.\"),\n    minimum: localize('schema.json.minimum', \"The minimum numerical value, inclusive by default.\"),\n    exclusiveMinimum: localize('schema.json.exclusiveMininum', \"Makes the minimum property exclusive.\"),\n    maxLength: localize('schema.json.maxLength', \"The maximum length of a string.\"),\n    minLength: localize('schema.json.minLength', \"The minimum length of a string.\"),\n    pattern: localize('schema.json.pattern', \"A regular expression to match the string against. It is not implicitly anchored.\"),\n    additionalItems: localize('schema.json.additionalItems', \"For arrays, only when items is set as an array. If it is a schema, then this schema validates items after the ones specified by the items array. If it is false, then additional items will cause validation to fail.\"),\n    items: localize('schema.json.items', \"For arrays. Can either be a schema to validate every element against or an array of schemas to validate each item against in order (the first schema will validate the first element, the second schema will validate the second element, and so on.\"),\n    maxItems: localize('schema.json.maxItems', \"The maximum number of items that can be inside an array. Inclusive.\"),\n    minItems: localize('schema.json.minItems', \"The minimum number of items that can be inside an array. Inclusive.\"),\n    uniqueItems: localize('schema.json.uniqueItems', \"If all of the items in the array must be unique. Defaults to false.\"),\n    maxProperties: localize('schema.json.maxProperties', \"The maximum number of properties an object can have. Inclusive.\"),\n    minProperties: localize('schema.json.minProperties', \"The minimum number of properties an object can have. Inclusive.\"),\n    required: localize('schema.json.required', \"An array of strings that lists the names of all properties required on this object.\"),\n    additionalProperties: localize('schema.json.additionalProperties', \"Either a schema or a boolean. If a schema, then used to validate all properties not matched by 'properties' or 'patternProperties'. If false, then any properties not matched by either will cause this schema to fail.\"),\n    definitions: localize('schema.json.definitions', \"Not used for validation. Place subschemas here that you wish to reference inline with $ref.\"),\n    properties: localize('schema.json.properties', \"A map of property names to schemas for each property.\"),\n    patternProperties: localize('schema.json.patternProperties', \"A map of regular expressions on property names to schemas for matching properties.\"),\n    dependencies: localize('schema.json.dependencies', \"A map of property names to either an array of property names or a schema. An array of property names means the property named in the key depends on the properties in the array being present in the object in order to be valid. If the value is a schema, then the schema is only applied to the object if the property in the key exists on the object.\"),\n    enum: localize('schema.json.enum', \"The set of literal values that are valid.\"),\n    type: localize('schema.json.type', \"Either a string of one of the basic schema types (number, integer, null, array, object, boolean, string) or an array of strings specifying a subset of those types.\"),\n    format: localize('schema.json.format', \"Describes the format expected for the value.\"),\n    allOf: localize('schema.json.allOf', \"An array of schemas, all of which must match.\"),\n    anyOf: localize('schema.json.anyOf', \"An array of schemas, where at least one must match.\"),\n    oneOf: localize('schema.json.oneOf', \"An array of schemas, exactly one of which must match.\"),\n    not: localize('schema.json.not', \"A schema which must not match.\"),\n    $id: localize('schema.json.$id', \"A unique identifier for the schema.\"),\n    $ref: localize('schema.json.$ref', \"Reference a definition hosted on any location.\"),\n    $comment: localize('schema.json.$comment', \"Comments from schema authors to readers or maintainers of the schema.\"),\n    readOnly: localize('schema.json.readOnly', \"Indicates that the value of the instance is managed exclusively by the owning authority.\"),\n    examples: localize('schema.json.examples', \"Sample JSON values associated with a particular schema, for the purpose of illustrating usage.\"),\n    contains: localize('schema.json.contains', \"An array instance is valid against \\\"contains\\\" if at least one of its elements is valid against the given schema.\"),\n    propertyNames: localize('schema.json.propertyNames', \"If the instance is an object, this keyword validates if every property name in the instance validates against the provided schema.\"),\n    const: localize('schema.json.const', \"An instance validates successfully against this keyword if its value is equal to the value of the keyword.\"),\n    contentMediaType: localize('schema.json.contentMediaType', \"Describes the media type of a string property.\"),\n    contentEncoding: localize('schema.json.contentEncoding', \"Describes the content encoding of a string property.\"),\n    if: localize('schema.json.if', \"The validation outcome of the \\\"if\\\" subschema controls which of the \\\"then\\\" or \\\"else\\\" keywords are evaluated.\"),\n    then: localize('schema.json.then', \"The \\\"if\\\" subschema is used for validation when the \\\"if\\\" subschema succeeds.\"),\n    else: localize('schema.json.else', \"The \\\"else\\\" subschema is used for validation when the \\\"if\\\" subschema fails.\")\n};\nfor (var schemaName in schemaContributions.schemas) {\n    var schema = schemaContributions.schemas[schemaName];\n    for (var property in schema.properties) {\n        var propertyObject = schema.properties[property];\n        if (propertyObject === true) {\n            propertyObject = schema.properties[property] = {};\n        }\n        var description = descriptions[property];\n        if (description) {\n            propertyObject['description'] = description;\n        }\n        else {\n            console.log(property + \": localize('schema.json.\" + property + \"', \\\"\\\")\");\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as jsonService from './_deps/vscode-json-languageservice/jsonLanguageService.js';\nimport * as ls from './_deps/vscode-languageserver-types/main.js';\nvar defaultSchemaRequestService;\nif (typeof fetch !== 'undefined') {\n    defaultSchemaRequestService = function (url) { return fetch(url).then(function (response) { return response.text(); }); };\n}\nvar PromiseAdapter = /** @class */ (function () {\n    function PromiseAdapter(executor) {\n        this.wrapped = new Promise(executor);\n    }\n    PromiseAdapter.prototype.then = function (onfulfilled, onrejected) {\n        var thenable = this.wrapped;\n        return thenable.then(onfulfilled, onrejected);\n    };\n    PromiseAdapter.prototype.getWrapped = function () {\n        return this.wrapped;\n    };\n    PromiseAdapter.resolve = function (v) {\n        return Promise.resolve(v);\n    };\n    PromiseAdapter.reject = function (v) {\n        return Promise.reject(v);\n    };\n    PromiseAdapter.all = function (values) {\n        return Promise.all(values);\n    };\n    return PromiseAdapter;\n}());\nvar JSONWorker = /** @class */ (function () {\n    function JSONWorker(ctx, createData) {\n        this._ctx = ctx;\n        this._languageSettings = createData.languageSettings;\n        this._languageId = createData.languageId;\n        this._languageService = jsonService.getLanguageService({\n            schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService,\n            promiseConstructor: PromiseAdapter\n        });\n        this._languageService.configure(this._languageSettings);\n    }\n    JSONWorker.prototype.doValidation = function (uri) {\n        var document = this._getTextDocument(uri);\n        if (document) {\n            var jsonDocument = this._languageService.parseJSONDocument(document);\n            return this._languageService.doValidation(document, jsonDocument);\n        }\n        return Promise.resolve([]);\n    };\n    JSONWorker.prototype.doComplete = function (uri, position) {\n        var document = this._getTextDocument(uri);\n        var jsonDocument = this._languageService.parseJSONDocument(document);\n        return this._languageService.doComplete(document, position, jsonDocument);\n    };\n    JSONWorker.prototype.doResolve = function (item) {\n        return this._languageService.doResolve(item);\n    };\n    JSONWorker.prototype.doHover = function (uri, position) {\n        var document = this._getTextDocument(uri);\n        var jsonDocument = this._languageService.parseJSONDocument(document);\n        return this._languageService.doHover(document, position, jsonDocument);\n    };\n    JSONWorker.prototype.format = function (uri, range, options) {\n        var document = this._getTextDocument(uri);\n        var textEdits = this._languageService.format(document, range, options);\n        return Promise.resolve(textEdits);\n    };\n    JSONWorker.prototype.resetSchema = function (uri) {\n        return Promise.resolve(this._languageService.resetSchema(uri));\n    };\n    JSONWorker.prototype.findDocumentSymbols = function (uri) {\n        var document = this._getTextDocument(uri);\n        var jsonDocument = this._languageService.parseJSONDocument(document);\n        var symbols = this._languageService.findDocumentSymbols(document, jsonDocument);\n        return Promise.resolve(symbols);\n    };\n    JSONWorker.prototype.findDocumentColors = function (uri) {\n        var document = this._getTextDocument(uri);\n        var stylesheet = this._languageService.parseJSONDocument(document);\n        var colorSymbols = this._languageService.findDocumentColors(document, stylesheet);\n        return Promise.resolve(colorSymbols);\n    };\n    JSONWorker.prototype.getColorPresentations = function (uri, color, range) {\n        var document = this._getTextDocument(uri);\n        var stylesheet = this._languageService.parseJSONDocument(document);\n        var colorPresentations = this._languageService.getColorPresentations(document, stylesheet, color, range);\n        return Promise.resolve(colorPresentations);\n    };\n    JSONWorker.prototype.provideFoldingRanges = function (uri, context) {\n        var document = this._getTextDocument(uri);\n        var ranges = this._languageService.getFoldingRanges(document, context);\n        return Promise.resolve(ranges);\n    };\n    JSONWorker.prototype._getTextDocument = function (uri) {\n        var models = this._ctx.getMirrorModels();\n        for (var _i = 0, models_1 = models; _i < models_1.length; _i++) {\n            var model = models_1[_i];\n            if (model.uri.toString() === uri) {\n                return ls.TextDocument.create(uri, this._languageId, model.version, model.getValue());\n            }\n        }\n        return null;\n    };\n    return JSONWorker;\n}());\nexport { JSONWorker };\nexport function create(ctx, createData) {\n    return new JSONWorker(ctx, createData);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from '../../vscode-languageserver-types/main.js';\nimport { createScanner } from '../../jsonc-parser/main.js';\nimport { FoldingRangeKind } from '../jsonLanguageTypes.js';\nexport function getFoldingRanges(document, context) {\n    var ranges = [];\n    var nestingLevels = [];\n    var stack = [];\n    var prevStart = -1;\n    var scanner = createScanner(document.getText(), false);\n    var token = scanner.scan();\n    function addRange(range) {\n        ranges.push(range);\n        nestingLevels.push(stack.length);\n    }\n    while (token !== 17 /* EOF */) {\n        switch (token) {\n            case 1 /* OpenBraceToken */:\n            case 3 /* OpenBracketToken */: {\n                var startLine = document.positionAt(scanner.getTokenOffset()).line;\n                var range = { startLine: startLine, endLine: startLine, kind: token === 1 /* OpenBraceToken */ ? 'object' : 'array' };\n                stack.push(range);\n                break;\n            }\n            case 2 /* CloseBraceToken */:\n            case 4 /* CloseBracketToken */: {\n                var kind = token === 2 /* CloseBraceToken */ ? 'object' : 'array';\n                if (stack.length > 0 && stack[stack.length - 1].kind === kind) {\n                    var range = stack.pop();\n                    var line = document.positionAt(scanner.getTokenOffset()).line;\n                    if (range && line > range.startLine + 1 && prevStart !== range.startLine) {\n                        range.endLine = line - 1;\n                        addRange(range);\n                        prevStart = range.startLine;\n                    }\n                }\n                break;\n            }\n            case 13 /* BlockCommentTrivia */: {\n                var startLine = document.positionAt(scanner.getTokenOffset()).line;\n                var endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;\n                if (scanner.getTokenError() === 1 /* UnexpectedEndOfComment */ && startLine + 1 < document.lineCount) {\n                    scanner.setPosition(document.offsetAt(Position.create(startLine + 1, 0)));\n                }\n                else {\n                    if (startLine < endLine) {\n                        addRange({ startLine: startLine, endLine: endLine, kind: FoldingRangeKind.Comment });\n                        prevStart = startLine;\n                    }\n                }\n                break;\n            }\n            case 12 /* LineCommentTrivia */: {\n                var text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());\n                var m = text.match(/^\\/\\/\\s*#(region\\b)|(endregion\\b)/);\n                if (m) {\n                    var line = document.positionAt(scanner.getTokenOffset()).line;\n                    if (m[1]) { // start pattern match\n                        var range = { startLine: line, endLine: line, kind: FoldingRangeKind.Region };\n                        stack.push(range);\n                    }\n                    else {\n                        var i = stack.length - 1;\n                        while (i >= 0 && stack[i].kind !== FoldingRangeKind.Region) {\n                            i--;\n                        }\n                        if (i >= 0) {\n                            var range = stack[i];\n                            stack.length = i;\n                            if (line > range.startLine && prevStart !== range.startLine) {\n                                range.endLine = line;\n                                addRange(range);\n                                prevStart = range.startLine;\n                            }\n                        }\n                    }\n                }\n                break;\n            }\n        }\n        token = scanner.scan();\n    }\n    var rangeLimit = context && context.rangeLimit;\n    if (typeof rangeLimit !== 'number' || ranges.length <= rangeLimit) {\n        return ranges;\n    }\n    var counts = [];\n    for (var _i = 0, nestingLevels_1 = nestingLevels; _i < nestingLevels_1.length; _i++) {\n        var level = nestingLevels_1[_i];\n        if (level < 30) {\n            counts[level] = (counts[level] || 0) + 1;\n        }\n    }\n    var entries = 0;\n    var maxLevel = 0;\n    for (var i = 0; i < counts.length; i++) {\n        var n = counts[i];\n        if (n) {\n            if (n + entries > rangeLimit) {\n                maxLevel = i;\n                break;\n            }\n            entries += n;\n        }\n    }\n    var result = [];\n    for (var i = 0; i < ranges.length; i++) {\n        var level = nestingLevels[i];\n        if (typeof level === 'number') {\n            if (level < maxLevel || (level === maxLevel && entries++ < rangeLimit)) {\n                result.push(ranges[i]);\n            }\n        }\n    }\n    return result;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Range } from '../../vscode-languageserver-types/main.js';\nimport { createScanner } from '../../jsonc-parser/main.js';\nimport { SelectionRangeKind } from '../jsonLanguageTypes.js';\nexport function getSelectionRanges(document, positions, doc) {\n    function getSelectionRange(position) {\n        var offset = document.offsetAt(position);\n        var node = doc.getNodeFromOffset(offset, true);\n        if (!node) {\n            return [];\n        }\n        var result = [];\n        while (node) {\n            switch (node.type) {\n                case 'string':\n                case 'object':\n                case 'array':\n                    // range without \", [ or {\n                    var cStart = node.offset + 1, cEnd = node.offset + node.length - 1;\n                    if (cStart < cEnd && offset >= cStart && offset <= cEnd) {\n                        result.push(newRange(cStart, cEnd));\n                    }\n                    result.push(newRange(node.offset, node.offset + node.length));\n                    break;\n                case 'number':\n                case 'boolean':\n                case 'null':\n                case 'property':\n                    result.push(newRange(node.offset, node.offset + node.length));\n                    break;\n            }\n            if (node.type === 'property' || node.parent && node.parent.type === 'array') {\n                var afterCommaOffset = getOffsetAfterNextToken(node.offset + node.length, 5 /* CommaToken */);\n                if (afterCommaOffset !== -1) {\n                    result.push(newRange(node.offset, afterCommaOffset));\n                }\n            }\n            node = node.parent;\n        }\n        return result;\n    }\n    function newRange(start, end) {\n        return {\n            range: Range.create(document.positionAt(start), document.positionAt(end)),\n            kind: SelectionRangeKind.Declaration\n        };\n    }\n    var scanner = createScanner(document.getText(), true);\n    function getOffsetAfterNextToken(offset, expectedToken) {\n        scanner.setPosition(offset);\n        var token = scanner.scan();\n        if (token === expectedToken) {\n            return scanner.getTokenOffset() + scanner.getTokenLength();\n        }\n        return -1;\n    }\n    return positions.map(getSelectionRange);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, MarkedString } from '../vscode-languageserver-types/main.js';\nimport { JSONCompletion } from './services/jsonCompletion.js';\nimport { JSONHover } from './services/jsonHover.js';\nimport { JSONValidation } from './services/jsonValidation.js';\nimport { JSONDocumentSymbols } from './services/jsonDocumentSymbols.js';\nimport { parse as parseJSON, newJSONDocument } from './parser/jsonParser.js';\nimport { schemaContributions } from './services/configuration.js';\nimport { JSONSchemaService } from './services/jsonSchemaService.js';\nimport { getFoldingRanges } from './services/jsonFolding.js';\nimport { getSelectionRanges } from './services/jsonSelectionRanges.js';\nimport { format as formatJSON } from '../jsonc-parser/main.js';\nexport * from './jsonLanguageTypes.js';\nexport { TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, MarkedString };\nexport function getLanguageService(params) {\n    var promise = params.promiseConstructor || Promise;\n    var jsonSchemaService = new JSONSchemaService(params.schemaRequestService, params.workspaceContext, promise);\n    jsonSchemaService.setSchemaContributions(schemaContributions);\n    var jsonCompletion = new JSONCompletion(jsonSchemaService, params.contributions, promise, params.clientCapabilities);\n    var jsonHover = new JSONHover(jsonSchemaService, params.contributions, promise);\n    var jsonDocumentSymbols = new JSONDocumentSymbols(jsonSchemaService);\n    var jsonValidation = new JSONValidation(jsonSchemaService, promise);\n    return {\n        configure: function (settings) {\n            jsonSchemaService.clearExternalSchemas();\n            if (settings.schemas) {\n                settings.schemas.forEach(function (settings) {\n                    jsonSchemaService.registerExternalSchema(settings.uri, settings.fileMatch, settings.schema);\n                });\n            }\n            jsonValidation.configure(settings);\n        },\n        resetSchema: function (uri) { return jsonSchemaService.onResourceChange(uri); },\n        doValidation: jsonValidation.doValidation.bind(jsonValidation),\n        parseJSONDocument: function (document) { return parseJSON(document, { collectComments: true }); },\n        newJSONDocument: function (root, diagnostics) { return newJSONDocument(root, diagnostics); },\n        doResolve: jsonCompletion.doResolve.bind(jsonCompletion),\n        doComplete: jsonCompletion.doComplete.bind(jsonCompletion),\n        findDocumentSymbols: jsonDocumentSymbols.findDocumentSymbols.bind(jsonDocumentSymbols),\n        findDocumentSymbols2: jsonDocumentSymbols.findDocumentSymbols2.bind(jsonDocumentSymbols),\n        findColorSymbols: function (d, s) { return jsonDocumentSymbols.findDocumentColors(d, s).then(function (s) { return s.map(function (s) { return s.range; }); }); },\n        findDocumentColors: jsonDocumentSymbols.findDocumentColors.bind(jsonDocumentSymbols),\n        getColorPresentations: jsonDocumentSymbols.getColorPresentations.bind(jsonDocumentSymbols),\n        doHover: jsonHover.doHover.bind(jsonHover),\n        getFoldingRanges: getFoldingRanges,\n        getSelectionRanges: getSelectionRanges,\n        format: function (d, r, o) {\n            var range = void 0;\n            if (r) {\n                var offset = d.offsetAt(r.start);\n                var length = d.offsetAt(r.end) - offset;\n                range = { offset: offset, length: length };\n            }\n            var options = { tabSize: o ? o.tabSize : 4, insertSpaces: o ? o.insertSpaces : true, eol: '\\n' };\n            return formatJSON(d.getText(), range, options).map(function (e) {\n                return TextEdit.replace(Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);\n            });\n        }\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as worker from '../../editor/editor.worker.js';\nimport { JSONWorker } from './jsonWorker.js';\nself.onmessage = function () {\n    // ignore the first message\n    worker.initialize(function (ctx, createData) {\n        return new JSONWorker(ctx, createData);\n    });\n};\n"],"sourceRoot":""}