editor.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:///(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/hash.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/base/common/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"],"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","LANGUAGE_DEFAULT","_isWindows","_isMacintosh","_isLinux","_isWeb","_locale","undefined","_userAgent","isElectronRenderer","process","versions","electron","type","navigator","platform","rawNlsConfig","nlsConfig","JSON","parse","resolved","availableLanguages","locale","_translationsConfigFile","e","userAgent","indexOf","maxTouchPoints","language","isWindows","isWeb","_globals","self","global","globals","setImmediate","postMessage","importScripts","pending_1","addEventListener","data","vscodeSetImmediateId","len","length","candidate","id","splice","callback","lastId_1","myId","push","nextTick","_promise","Promise","resolve","fn","args","Array","slice","arguments","shift","setTimeout","apply","arch","execPath","title","pid","browser","env","argv","binding","Error","path","cwd","chdir","dir","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","factory","this","finallyConstructor","constructor","then","reason","reject","setTimeoutFunc","noop","thisArg","TypeError","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","cb","onFulfilled","onRejected","ret","promise","newValue","finale","_unhandledRejectionFn","Handler","done","ex","prom","all","arr","remaining","res","val","race","values","err","console","warn","globalNS","window","g","Function","normalizeArray","parts","allowAboveRoot","up","last","unshift","basename","start","end","matchedSlash","charCodeAt","filter","xs","f","resolvedPath","resolvedAbsolute","charAt","split","join","normalize","isAbsolute","trailingSlash","substr","paths","index","relative","from","to","trim","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","str","ErrorHandler","listeners","unexpectedErrorHandler","stack","message","emit","forEach","listener","onUnexpectedError","onUnexpectedExternalError","errorHandler","isPromiseCanceledError","transformErrorForSerialization","error","name_1","stacktrace","$isError","canceledName","illegalArgument","TRACK_DISPOSABLES","__is_disposable_tracked__","markTracked","x","Disposable","None","_a","trackDisposable","log","disposables","isArray","dispose","combinedDisposable","_i","toDisposable","DisposableStore","_toDispose","Set","_isDisposed","clear","item","add","_store","_register","freeze","MutableDisposable","set","configurable","ImmortalReference","getAllPropertyNames","obj","proto","getPrototypeOf","getOwnPropertyNames","getAllMethodNames","methods","prop","createProxyObject","methodNames","invoke","createProxyMethod","method","result","methodNames_1","methodName","__extends","extendStatics","b","setPrototypeOf","__proto__","__","INITIALIZE","SimpleWorkerProtocol","handler","_workerId","_handler","_lastSentReq","_pendingReplies","setWorkerId","workerId","sendMessage","_this","req","String","_send","vsWorker","handleMessage","_handleMessage","msg","seq","replyMessage","reply","requestMessage","detail","transfer","ArrayBuffer","_super","SimpleWorkerClient","workerFactory","host","lazyProxyReject","_worker","_protocol","getId","loaderConfiguration","require","getConfig","requirejs","contexts","_","config","hostMethods","_onModuleLoaded","stringify","proxyMethodRequest","_request","_lazyProxy","availableMethods","_onError","getProxyObject","info","SimpleWorkerServer","requestHandlerFactory","_requestHandlerFactory","_requestHandler","onmessage","initialize","loaderConfig","hostProxy","baseUrl","vs","catchError","mergeSort","compare","_sort","_merge","a","lo","mid","hi","aux","leftIdx","rightIdx","DiffChange","originalStart","originalLength","modifiedStart","modifiedLength","getOriginalEnd","getModifiedEnd","numberHash","initialHashVal","stringHash","hashVal","length_1","StringDiffSequence","source","getElements","characters","Int32Array","stringDiff","original","modified","pretty","ComputeDiff","changes","Iterator","Debug","Assert","condition","MyArray","Copy","sourceArray","sourceIndex","destinationArray","destinationIndex","Copy2","DiffChangeHelper","m_changes","m_originalStart","m_modifiedStart","m_originalCount","m_modifiedCount","MarkNextChange","AddOriginalElement","originalIndex","modifiedIndex","AddModifiedElement","getChanges","getReverseChanges","reverse","LcsDiff","originalSequence","modifiedSequence","continueProcessingPredicate","ContinueProcessingPredicate","_getElements","originalStringElements","originalElementsOrHash","originalHasStrings","_b","modifiedStringElements","modifiedElementsOrHash","modifiedHasStrings","_hasStrings","_originalStringElements","_originalElementsOrHash","_modifiedStringElements","_modifiedElementsOrHash","m_forwardHistory","m_reverseHistory","_isStringArray","sequence","elements","hashes","ElementsAreEqual","newIndex","OriginalElementsAreEqual","index1","index2","ModifiedElementsAreEqual","_ComputeDiff","originalEnd","modifiedEnd","quitEarlyArr","ComputeDiffRecursive","PrettifyChanges","quitEarly","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","WALKTRACE","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","historyIndex","diagonal","originalStartPoint","modifiedStartPoint","lastForwardChange","max","maxDifferences","numDiagonals","delta","numDifferences","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","tempOriginalIndex","abs","matchLengthOfLongest","temp","change","originalStop","modifiedStop","checkOriginal","checkModified","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","score","_OriginalIsBoundary","test","_OriginalRegionIsBoundary","_ModifiedIsBoundary","_ModifiedRegionIsBoundary","originalScore","modifiedScore","left","right","diagonalBaseIndex","diagonalsBelow","diagonalsAbove","diffEven","lowerBoundEven","upperBoundEven","FIN","_empty","next","empty","single","fromArray","array","fromNativeIterator","it","map","iterator","element","collect","atMost","Number","POSITIVE_INFINITY","iterators","chain","ChainableIterator","ArrayIterator","items","first","current","ArrayNavigator","previous","parent","MappedIterator","_schemePattern","_singleSlashStart","_doubleSlashStart","_validateUri","_strict","scheme","authority","query","fragment","_schemeFix","_referenceResolution","_slash","_regexp","URI","schemeOrData","isUri","thing","fsPath","with","toString","_makeFsPath","_URI","match","exec","percentDecode","file","replace","idx","substring","components","skipEncoding","_asFormatted","toJSON","revive","_formatted","external","_fsPath","_sep","_pathSepMarker","$mid","encodeTable","encodeURIComponentFast","uriComponent","allowSlash","nativeEncodePos","pos","encodeURIComponent","escaped","encodeURIComponentMinimal","uri","toLowerCase","encoder","userinfo","fromCharCode","decodeURIComponentGraceful","decodeURIComponent","_rEncodedAsHex","Position","lineNumber","column","newLineNumber","newColumn","deltaLineNumber","deltaColumn","equals","other","isBefore","isBeforeOrEqual","aLineNumber","bLineNumber","aColumn","bColumn","clone","lift","isIPosition","Range","startLineNumber","startColumn","endLineNumber","endColumn","isEmpty","range","containsPosition","position","containsRange","otherRange","strictContainsRange","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","GraphemeBreakTree","_data","getGraphemeBreakRawData","getInstance","_INSTANCE","getGraphemeBreakType","codePoint","nodeCount","nodeIndex","MINIMUM_MATCHING_CHARACTER_LENGTH","computeDiff","diffAlgo","LineSequence","lines","startColumns","endColumns","getFirstNonBlankColumn","getLastNonBlankColumn","_startColumns","_endColumns","getStartLineNumber","getEndLineNumber","createCharSequence","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","continueCharDiff","shouldComputeCharChanges","shouldPostProcessCharChanges","length_2","DiffComputer","originalLines","modifiedLines","opts","shouldMakePrettyDiff","continueLineDiff","createContinueProcessingPredicate","maxComputationTime","diffResult","lineChanges","length_3","originalLineIndex","modifiedLineIndex","nextChange","originalLine","modifiedLine","originalChar","modifiedChar","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","txt","defaultValue","maximumRuntime","startTime","Date","now","toUint8","v","toUint32","PrefixSumIndexOfResult","remainder","PrefixSumComputer","prefixSum","Uint32Array","prefixSumValidIndex","insertValues","insertIndex","oldValues","oldPrefixSum","insertValuesLen","subarray","changeValue","removeValues","cnt","maxCnt","getTotalValue","_getAccumulatedValue","getAccumulatedValue","getIndexOf","accumulatedValue","floor","low","high","midStop","midStart","MirrorTextModel","eol","versionId","_uri","_lines","_eol","_versionId","_lineStarts","getText","onEvents","changes_1","_acceptDeleteRange","_acceptInsertText","text","_ensureLineStarts","eolLength","linesLength","lineStartValues","_setLineText","lineIndex","insertText","insertLines","newLengths","USUAL_WORD_SEPARATORS","createWordRegExp","allowInWords","USUAL_WORD_SEPARATORS_1","RegExp","DEFAULT_WORD_REGEXP","ensureValidWordDefinition","wordDefinition","flags","ignoreCase","multiline","unicode","lastIndex","getWordAtPosFast","textOffset","lastIndexOf","matchIndex","word","getWordAtPosSlow","getWordAtText","CharacterClassifier","_defaultValue","_asciiMap","_createAsciiMap","_map","Map","asciiMap","Uint8Array","charCode","Uint8Matrix","CharacterSet","_actual","has","rows","cols","row","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","didCall","Node","Undefined","prev","LinkedList","_first","_last","_size","_insert","atTheEnd","newNode","oldLast","oldFirst","didRemove","_remove","pop","node","anchor","toArray","Event","once","event","thisArgs","didFire","snapshot","each","signal","any","events","reduce","merge","initial","output","emitter","onFirstListenerAdd","fire","onLastListenerRemove","debounce","delay","leading","leakWarningThreshold","subscription","numDebouncedCalls","cur","clearTimeout","_output","stopwatch","getTime","latch","cache","firstCall","shouldEmit","buffer","_buffer","flush","onFirstListenerDidAdd","ChainableEvent","on","fromNodeEventEmitter","eventName","removeListener","fromDOMEventEmitter","removeEventListener","fromPromise","toPromise","_globalLeakWarningThreshold","LeakageMonitor","customThreshold","random","_warnCountdown","_stacks","check","listenerCount","threshold","count","topStack_1","topCount_1","Emitter","options","_disposed","_options","_leakageMon","_event","_listeners","firstListener","removeMonitor","remove","onListenerDidAdd","size","_noop","hasListeners","_deliveryQueue","iter","event_1","shortcutEvent","PauseableEmitter","_isPaused","_eventQueue","_mergeFn","pause","resume","EventMultiplexer","hook","unhook","EventBufferer","buffers","wrapEvent","bufferEvents","Relay","listening","inputEvent","inputEventListener","context","CancellationToken","isCancellationToken","Cancelled","isCancellationRequested","onCancellationRequested","KeyCodeUtils","MutableToken","_isCancelled","_emitter","cancel","CancellationTokenSource","_token","_parentListener","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","isDuplicateModifierCase","AccessibilitySupport","CompletionItemInsertTextRule","CompletionItemKind","CompletionItemTag","CompletionTriggerKind","ContentWidgetPositionPreference","CursorChangeReason","DefaultEndOfLine","DocumentHighlightKind","EditorAutoIndentStrategy","EditorOption","EndOfLinePreference","EndOfLineSequence","IndentAction","KeyCode","MarkerSeverity","MarkerTag","MinimapPosition","MouseTargetType","OverlayWidgetPositionPreference","OverviewRulerLane","RenderLineNumbersType","RenderMinimap","ScrollType","ScrollbarVisibility","SelectionDirection","SignatureHelpTriggerKind","SymbolKind","SymbolTag","TextEditorCursorBlinkingStyle","TextEditorCursorStyle","TrackedRangeStickiness","WrappingIndent","ChordKeybinding","ResolvedKeybindingPart","kbLabel","kbAriaLabel","keyLabel","keyAriaLabel","ResolvedKeybinding","Selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","equalsSelection","selectionsEqual","getDirection","getPosition","liftSelection","sel","selectionsArrEqual","isISelection","createWithDirection","direction","Token","offset","TokenizationResult","tokens","endState","TokenizationResult2","KeyMod","chord","CtrlCmd","Shift","Alt","WinCtrl","createMonacoBaseAPI","editor","languages","Uri","__awaiter","_arguments","P","generator","adopt","fulfilled","step","rejected","__generator","body","y","label","sent","trys","ops","verb","op","MirrorModel","getValue","getLinesContent","getWordAtPosition","wordAtText","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","foreignModuleFactory","_host","_models","_foreignModuleFactory","_foreignModule","_getModel","_getModels","keys","acceptNewModel","EOL","acceptModelChanged","strURL","acceptRemovedModel","originalUrl","modifiedUrl","ignoreTrimWhitespace","diffComputer","identical","_modelsAreIdentical","originalLineCount","modifiedLineCount","computeMoreMinimalEdits","modelUrl","edits","lastEol","edits_1","editOffset","newEdit","_c","aRng","bRng","_diffLimit","textualSuggest","wordDef","wordDefFlags","seen","wordDefRegExp","wordAt","_suggestionsLimit","computeWordRanges","words_1","selectionText","wordRange","loadForeignModule","createData","foreignHostMethods","fhr","foreignHost","ctx","getMirrorModels","fmr","monaco","initialized","foreignModule","simpleWorker"],"mappings":"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","file":"editor.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 = \"e500\");\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\nvar LANGUAGE_DEFAULT = 'en';\r\nvar _isWindows = false;\r\nvar _isMacintosh = false;\r\nvar _isLinux = false;\r\nvar _isNative = false;\r\nvar _isWeb = false;\r\nvar _isIOS = false;\r\nvar _locale = undefined;\r\nvar _language = LANGUAGE_DEFAULT;\r\nvar _translationsConfigFile = undefined;\r\nvar _userAgent = undefined;\r\nvar isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\r\n// OS detection\r\nif (typeof navigator === 'object' && !isElectronRenderer) {\r\n    _userAgent = navigator.userAgent;\r\n    _isWindows = _userAgent.indexOf('Windows') >= 0;\r\n    _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;\r\n    _isIOS = _userAgent.indexOf('Macintosh') >= 0 && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;\r\n    _isLinux = _userAgent.indexOf('Linux') >= 0;\r\n    _isWeb = true;\r\n    _locale = navigator.language;\r\n    _language = _locale;\r\n}\r\nelse if (typeof process === 'object') {\r\n    _isWindows = (process.platform === 'win32');\r\n    _isMacintosh = (process.platform === 'darwin');\r\n    _isLinux = (process.platform === 'linux');\r\n    _locale = LANGUAGE_DEFAULT;\r\n    _language = LANGUAGE_DEFAULT;\r\n    var rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];\r\n    if (rawNlsConfig) {\r\n        try {\r\n            var nlsConfig = JSON.parse(rawNlsConfig);\r\n            var resolved = nlsConfig.availableLanguages['*'];\r\n            _locale = nlsConfig.locale;\r\n            // VSCode's default language is 'en'\r\n            _language = resolved ? resolved : LANGUAGE_DEFAULT;\r\n            _translationsConfigFile = nlsConfig._translationsConfigFile;\r\n        }\r\n        catch (e) {\r\n        }\r\n    }\r\n    _isNative = true;\r\n}\r\nvar _platform = 0 /* Web */;\r\nif (_isMacintosh) {\r\n    _platform = 1 /* Mac */;\r\n}\r\nelse if (_isWindows) {\r\n    _platform = 3 /* Windows */;\r\n}\r\nelse if (_isLinux) {\r\n    _platform = 2 /* Linux */;\r\n}\r\nexport var isWindows = _isWindows;\r\nexport var isMacintosh = _isMacintosh;\r\nexport var isLinux = _isLinux;\r\nexport var isNative = _isNative;\r\nexport var isWeb = _isWeb;\r\nexport var isIOS = _isIOS;\r\nvar _globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});\r\nexport var globals = _globals;\r\nexport var setImmediate = (function defineSetImmediate() {\r\n    if (globals.setImmediate) {\r\n        return globals.setImmediate.bind(globals);\r\n    }\r\n    if (typeof globals.postMessage === 'function' && !globals.importScripts) {\r\n        var pending_1 = [];\r\n        globals.addEventListener('message', function (e) {\r\n            if (e.data && e.data.vscodeSetImmediateId) {\r\n                for (var i = 0, len = pending_1.length; i < len; i++) {\r\n                    var candidate = pending_1[i];\r\n                    if (candidate.id === e.data.vscodeSetImmediateId) {\r\n                        pending_1.splice(i, 1);\r\n                        candidate.callback();\r\n                        return;\r\n                    }\r\n                }\r\n            }\r\n        });\r\n        var lastId_1 = 0;\r\n        return function (callback) {\r\n            var myId = ++lastId_1;\r\n            pending_1.push({\r\n                id: myId,\r\n                callback: callback\r\n            });\r\n            globals.postMessage({ vscodeSetImmediateId: myId }, '*');\r\n        };\r\n    }\r\n    if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {\r\n        return process.nextTick.bind(process);\r\n    }\r\n    var _promise = Promise.resolve();\r\n    return function (callback) { return _promise.then(callback); };\r\n})();\r\nexport var OS = (_isMacintosh ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));\r\n","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 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","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","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// 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// 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  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\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","/*---------------------------------------------------------------------------------------------\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// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\r\nvar ErrorHandler = /** @class */ (function () {\r\n    function ErrorHandler() {\r\n        this.listeners = [];\r\n        this.unexpectedErrorHandler = function (e) {\r\n            setTimeout(function () {\r\n                if (e.stack) {\r\n                    throw new Error(e.message + '\\n\\n' + e.stack);\r\n                }\r\n                throw e;\r\n            }, 0);\r\n        };\r\n    }\r\n    ErrorHandler.prototype.emit = function (e) {\r\n        this.listeners.forEach(function (listener) {\r\n            listener(e);\r\n        });\r\n    };\r\n    ErrorHandler.prototype.onUnexpectedError = function (e) {\r\n        this.unexpectedErrorHandler(e);\r\n        this.emit(e);\r\n    };\r\n    // For external errors, we don't want the listeners to be called\r\n    ErrorHandler.prototype.onUnexpectedExternalError = function (e) {\r\n        this.unexpectedErrorHandler(e);\r\n    };\r\n    return ErrorHandler;\r\n}());\r\nexport { ErrorHandler };\r\nexport var errorHandler = new ErrorHandler();\r\nexport function onUnexpectedError(e) {\r\n    // ignore errors from cancelled promises\r\n    if (!isPromiseCanceledError(e)) {\r\n        errorHandler.onUnexpectedError(e);\r\n    }\r\n    return undefined;\r\n}\r\nexport function onUnexpectedExternalError(e) {\r\n    // ignore errors from cancelled promises\r\n    if (!isPromiseCanceledError(e)) {\r\n        errorHandler.onUnexpectedExternalError(e);\r\n    }\r\n    return undefined;\r\n}\r\nexport function transformErrorForSerialization(error) {\r\n    if (error instanceof Error) {\r\n        var name_1 = error.name, message = error.message;\r\n        var stack = error.stacktrace || error.stack;\r\n        return {\r\n            $isError: true,\r\n            name: name_1,\r\n            message: message,\r\n            stack: stack\r\n        };\r\n    }\r\n    // return as is\r\n    return error;\r\n}\r\nvar canceledName = 'Canceled';\r\n/**\r\n * Checks if the given error is a promise in canceled state\r\n */\r\nexport function isPromiseCanceledError(error) {\r\n    return error instanceof Error && error.name === canceledName && error.message === canceledName;\r\n}\r\n/**\r\n * Returns an error that signals cancellation.\r\n */\r\nexport function canceled() {\r\n    var error = new Error(canceledName);\r\n    error.name = error.message;\r\n    return error;\r\n}\r\nexport function illegalArgument(name) {\r\n    if (name) {\r\n        return new Error(\"Illegal argument: \" + name);\r\n    }\r\n    else {\r\n        return new Error('Illegal argument');\r\n    }\r\n}\r\nexport function illegalState(name) {\r\n    if (name) {\r\n        return new Error(\"Illegal state: \" + name);\r\n    }\r\n    else {\r\n        return new Error('Illegal state');\r\n    }\r\n}\r\n","/**\r\n * Enables logging of potentially leaked disposables.\r\n *\r\n * A disposable is considered leaked if it is not disposed or not registered as the child of\r\n * another disposable. This tracking is very simple an only works for classes that either\r\n * extend Disposable or use a DisposableStore. This means there are a lot of false positives.\r\n */\r\nvar TRACK_DISPOSABLES = false;\r\nvar __is_disposable_tracked__ = '__is_disposable_tracked__';\r\nfunction markTracked(x) {\r\n    if (!TRACK_DISPOSABLES) {\r\n        return;\r\n    }\r\n    if (x && x !== Disposable.None) {\r\n        try {\r\n            x[__is_disposable_tracked__] = true;\r\n        }\r\n        catch (_a) {\r\n            // noop\r\n        }\r\n    }\r\n}\r\nfunction trackDisposable(x) {\r\n    if (!TRACK_DISPOSABLES) {\r\n        return x;\r\n    }\r\n    var stack = new Error('Potentially leaked disposable').stack;\r\n    setTimeout(function () {\r\n        if (!x[__is_disposable_tracked__]) {\r\n            console.log(stack);\r\n        }\r\n    }, 3000);\r\n    return x;\r\n}\r\nexport function isDisposable(thing) {\r\n    return typeof thing.dispose === 'function'\r\n        && thing.dispose.length === 0;\r\n}\r\nexport function dispose(disposables) {\r\n    if (Array.isArray(disposables)) {\r\n        disposables.forEach(function (d) {\r\n            if (d) {\r\n                markTracked(d);\r\n                d.dispose();\r\n            }\r\n        });\r\n        return [];\r\n    }\r\n    else if (disposables) {\r\n        markTracked(disposables);\r\n        disposables.dispose();\r\n        return disposables;\r\n    }\r\n    else {\r\n        return undefined;\r\n    }\r\n}\r\nexport function combinedDisposable() {\r\n    var disposables = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        disposables[_i] = arguments[_i];\r\n    }\r\n    disposables.forEach(markTracked);\r\n    return trackDisposable({ dispose: function () { return dispose(disposables); } });\r\n}\r\nexport function toDisposable(fn) {\r\n    var self = trackDisposable({\r\n        dispose: function () {\r\n            markTracked(self);\r\n            fn();\r\n        }\r\n    });\r\n    return self;\r\n}\r\nvar DisposableStore = /** @class */ (function () {\r\n    function DisposableStore() {\r\n        this._toDispose = new Set();\r\n        this._isDisposed = false;\r\n    }\r\n    /**\r\n     * Dispose of all registered disposables and mark this object as disposed.\r\n     *\r\n     * Any future disposables added to this object will be disposed of on `add`.\r\n     */\r\n    DisposableStore.prototype.dispose = function () {\r\n        if (this._isDisposed) {\r\n            return;\r\n        }\r\n        markTracked(this);\r\n        this._isDisposed = true;\r\n        this.clear();\r\n    };\r\n    /**\r\n     * Dispose of all registered disposables but do not mark this object as disposed.\r\n     */\r\n    DisposableStore.prototype.clear = function () {\r\n        this._toDispose.forEach(function (item) { return item.dispose(); });\r\n        this._toDispose.clear();\r\n    };\r\n    DisposableStore.prototype.add = function (t) {\r\n        if (!t) {\r\n            return t;\r\n        }\r\n        if (t === this) {\r\n            throw new Error('Cannot register a disposable on itself!');\r\n        }\r\n        markTracked(t);\r\n        if (this._isDisposed) {\r\n            console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);\r\n        }\r\n        else {\r\n            this._toDispose.add(t);\r\n        }\r\n        return t;\r\n    };\r\n    return DisposableStore;\r\n}());\r\nexport { DisposableStore };\r\nvar Disposable = /** @class */ (function () {\r\n    function Disposable() {\r\n        this._store = new DisposableStore();\r\n        trackDisposable(this);\r\n    }\r\n    Disposable.prototype.dispose = function () {\r\n        markTracked(this);\r\n        this._store.dispose();\r\n    };\r\n    Disposable.prototype._register = function (t) {\r\n        if (t === this) {\r\n            throw new Error('Cannot register a disposable on itself!');\r\n        }\r\n        return this._store.add(t);\r\n    };\r\n    Disposable.None = Object.freeze({ dispose: function () { } });\r\n    return Disposable;\r\n}());\r\nexport { Disposable };\r\n/**\r\n * Manages the lifecycle of a disposable value that may be changed.\r\n *\r\n * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can\r\n * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.\r\n */\r\nvar MutableDisposable = /** @class */ (function () {\r\n    function MutableDisposable() {\r\n        this._isDisposed = false;\r\n        trackDisposable(this);\r\n    }\r\n    Object.defineProperty(MutableDisposable.prototype, \"value\", {\r\n        get: function () {\r\n            return this._isDisposed ? undefined : this._value;\r\n        },\r\n        set: function (value) {\r\n            if (this._isDisposed || value === this._value) {\r\n                return;\r\n            }\r\n            if (this._value) {\r\n                this._value.dispose();\r\n            }\r\n            if (value) {\r\n                markTracked(value);\r\n            }\r\n            this._value = value;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    MutableDisposable.prototype.clear = function () {\r\n        this.value = undefined;\r\n    };\r\n    MutableDisposable.prototype.dispose = function () {\r\n        this._isDisposed = true;\r\n        markTracked(this);\r\n        if (this._value) {\r\n            this._value.dispose();\r\n        }\r\n        this._value = undefined;\r\n    };\r\n    return MutableDisposable;\r\n}());\r\nexport { MutableDisposable };\r\nvar ImmortalReference = /** @class */ (function () {\r\n    function ImmortalReference(object) {\r\n        this.object = object;\r\n    }\r\n    ImmortalReference.prototype.dispose = function () { };\r\n    return ImmortalReference;\r\n}());\r\nexport { ImmortalReference };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar _typeof = {\r\n    number: 'number',\r\n    string: 'string',\r\n    undefined: 'undefined',\r\n    object: 'object',\r\n    function: 'function'\r\n};\r\n/**\r\n * @returns whether the provided parameter is a JavaScript Array or not.\r\n */\r\nexport function isArray(array) {\r\n    if (Array.isArray) {\r\n        return Array.isArray(array);\r\n    }\r\n    if (array && typeof (array.length) === _typeof.number && array.constructor === Array) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * @returns whether the provided parameter is a JavaScript String or not.\r\n */\r\nexport function isString(str) {\r\n    if (typeof (str) === _typeof.string || str instanceof String) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n *\r\n * @returns whether the provided parameter is of type `object` but **not**\r\n *\t`null`, an `array`, a `regexp`, nor a `date`.\r\n */\r\nexport function isObject(obj) {\r\n    // The method can't do a type cast since there are type (like strings) which\r\n    // are subclasses of any put not positvely matched by the function. Hence type\r\n    // narrowing results in wrong results.\r\n    return typeof obj === _typeof.object\r\n        && obj !== null\r\n        && !Array.isArray(obj)\r\n        && !(obj instanceof RegExp)\r\n        && !(obj instanceof Date);\r\n}\r\n/**\r\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\r\n * @returns whether the provided parameter is a JavaScript Number or not.\r\n */\r\nexport function isNumber(obj) {\r\n    if ((typeof (obj) === _typeof.number || obj instanceof Number) && !isNaN(obj)) {\r\n        return true;\r\n    }\r\n    return false;\r\n}\r\n/**\r\n * @returns whether the provided parameter is a JavaScript Boolean or not.\r\n */\r\nexport function isBoolean(obj) {\r\n    return obj === true || obj === false;\r\n}\r\n/**\r\n * @returns whether the provided parameter is undefined.\r\n */\r\nexport function isUndefined(obj) {\r\n    return typeof (obj) === _typeof.undefined;\r\n}\r\n/**\r\n * @returns whether the provided parameter is undefined or null.\r\n */\r\nexport function isUndefinedOrNull(obj) {\r\n    return isUndefined(obj) || obj === null;\r\n}\r\nexport function assertType(condition, type) {\r\n    if (!condition) {\r\n        throw new Error(type ? \"Unexpected type, expected '\" + type + \"'\" : 'Unexpected type');\r\n    }\r\n}\r\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\r\n/**\r\n * @returns whether the provided parameter is an empty JavaScript Object or not.\r\n */\r\nexport function isEmptyObject(obj) {\r\n    if (!isObject(obj)) {\r\n        return false;\r\n    }\r\n    for (var key in obj) {\r\n        if (hasOwnProperty.call(obj, key)) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * @returns whether the provided parameter is a JavaScript Function or not.\r\n */\r\nexport function isFunction(obj) {\r\n    return typeof obj === _typeof.function;\r\n}\r\nexport function validateConstraints(args, constraints) {\r\n    var len = Math.min(args.length, constraints.length);\r\n    for (var i = 0; i < len; i++) {\r\n        validateConstraint(args[i], constraints[i]);\r\n    }\r\n}\r\nexport function validateConstraint(arg, constraint) {\r\n    if (isString(constraint)) {\r\n        if (typeof arg !== constraint) {\r\n            throw new Error(\"argument does not match constraint: typeof \" + constraint);\r\n        }\r\n    }\r\n    else if (isFunction(constraint)) {\r\n        try {\r\n            if (arg instanceof constraint) {\r\n                return;\r\n            }\r\n        }\r\n        catch (_a) {\r\n            // ignore\r\n        }\r\n        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\r\n            return;\r\n        }\r\n        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\r\n            return;\r\n        }\r\n        throw new Error(\"argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true\");\r\n    }\r\n}\r\nexport function getAllPropertyNames(obj) {\r\n    var res = [];\r\n    var proto = Object.getPrototypeOf(obj);\r\n    while (Object.prototype !== proto) {\r\n        res = res.concat(Object.getOwnPropertyNames(proto));\r\n        proto = Object.getPrototypeOf(proto);\r\n    }\r\n    return res;\r\n}\r\nexport function getAllMethodNames(obj) {\r\n    var methods = [];\r\n    for (var _i = 0, _a = getAllPropertyNames(obj); _i < _a.length; _i++) {\r\n        var prop = _a[_i];\r\n        if (typeof obj[prop] === 'function') {\r\n            methods.push(prop);\r\n        }\r\n    }\r\n    return methods;\r\n}\r\nexport function createProxyObject(methodNames, invoke) {\r\n    var createProxyMethod = function (method) {\r\n        return function () {\r\n            var args = Array.prototype.slice.call(arguments, 0);\r\n            return invoke(method, args);\r\n        };\r\n    };\r\n    var result = {};\r\n    for (var _i = 0, methodNames_1 = methodNames; _i < methodNames_1.length; _i++) {\r\n        var methodName = methodNames_1[_i];\r\n        result[methodName] = createProxyMethod(methodName);\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Converts null to undefined, passes all other values through.\r\n */\r\nexport function withNullAsUndefined(x) {\r\n    return x === null ? undefined : x;\r\n}\r\n/**\r\n * Converts undefined to null, passes all other values through.\r\n */\r\nexport function withUndefinedAsNull(x) {\r\n    return typeof x === 'undefined' ? null : x;\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nimport { transformErrorForSerialization } from '../errors.js';\r\nimport { Disposable } from '../lifecycle.js';\r\nimport { isWeb } from '../platform.js';\r\nimport * as types from '../types.js';\r\nvar INITIALIZE = '$initialize';\r\nvar webWorkerWarningLogged = false;\r\nexport function logOnceWebWorkerWarning(err) {\r\n    if (!isWeb) {\r\n        // running tests\r\n        return;\r\n    }\r\n    if (!webWorkerWarningLogged) {\r\n        webWorkerWarningLogged = true;\r\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');\r\n    }\r\n    console.warn(err.message);\r\n}\r\nvar SimpleWorkerProtocol = /** @class */ (function () {\r\n    function SimpleWorkerProtocol(handler) {\r\n        this._workerId = -1;\r\n        this._handler = handler;\r\n        this._lastSentReq = 0;\r\n        this._pendingReplies = Object.create(null);\r\n    }\r\n    SimpleWorkerProtocol.prototype.setWorkerId = function (workerId) {\r\n        this._workerId = workerId;\r\n    };\r\n    SimpleWorkerProtocol.prototype.sendMessage = function (method, args) {\r\n        var _this = this;\r\n        var req = String(++this._lastSentReq);\r\n        return new Promise(function (resolve, reject) {\r\n            _this._pendingReplies[req] = {\r\n                resolve: resolve,\r\n                reject: reject\r\n            };\r\n            _this._send({\r\n                vsWorker: _this._workerId,\r\n                req: req,\r\n                method: method,\r\n                args: args\r\n            });\r\n        });\r\n    };\r\n    SimpleWorkerProtocol.prototype.handleMessage = function (message) {\r\n        if (!message || !message.vsWorker) {\r\n            return;\r\n        }\r\n        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\r\n            return;\r\n        }\r\n        this._handleMessage(message);\r\n    };\r\n    SimpleWorkerProtocol.prototype._handleMessage = function (msg) {\r\n        var _this = this;\r\n        if (msg.seq) {\r\n            var replyMessage = msg;\r\n            if (!this._pendingReplies[replyMessage.seq]) {\r\n                console.warn('Got reply to unknown seq');\r\n                return;\r\n            }\r\n            var reply = this._pendingReplies[replyMessage.seq];\r\n            delete this._pendingReplies[replyMessage.seq];\r\n            if (replyMessage.err) {\r\n                var err = replyMessage.err;\r\n                if (replyMessage.err.$isError) {\r\n                    err = new Error();\r\n                    err.name = replyMessage.err.name;\r\n                    err.message = replyMessage.err.message;\r\n                    err.stack = replyMessage.err.stack;\r\n                }\r\n                reply.reject(err);\r\n                return;\r\n            }\r\n            reply.resolve(replyMessage.res);\r\n            return;\r\n        }\r\n        var requestMessage = msg;\r\n        var req = requestMessage.req;\r\n        var result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\r\n        result.then(function (r) {\r\n            _this._send({\r\n                vsWorker: _this._workerId,\r\n                seq: req,\r\n                res: r,\r\n                err: undefined\r\n            });\r\n        }, function (e) {\r\n            if (e.detail instanceof Error) {\r\n                // Loading errors have a detail property that points to the actual error\r\n                e.detail = transformErrorForSerialization(e.detail);\r\n            }\r\n            _this._send({\r\n                vsWorker: _this._workerId,\r\n                seq: req,\r\n                res: undefined,\r\n                err: transformErrorForSerialization(e)\r\n            });\r\n        });\r\n    };\r\n    SimpleWorkerProtocol.prototype._send = function (msg) {\r\n        var transfer = [];\r\n        if (msg.req) {\r\n            var m = msg;\r\n            for (var i = 0; i < m.args.length; i++) {\r\n                if (m.args[i] instanceof ArrayBuffer) {\r\n                    transfer.push(m.args[i]);\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            var m = msg;\r\n            if (m.res instanceof ArrayBuffer) {\r\n                transfer.push(m.res);\r\n            }\r\n        }\r\n        this._handler.sendMessage(msg, transfer);\r\n    };\r\n    return SimpleWorkerProtocol;\r\n}());\r\n/**\r\n * Main thread side\r\n */\r\nvar SimpleWorkerClient = /** @class */ (function (_super) {\r\n    __extends(SimpleWorkerClient, _super);\r\n    function SimpleWorkerClient(workerFactory, moduleId, host) {\r\n        var _this = _super.call(this) || this;\r\n        var lazyProxyReject = null;\r\n        _this._worker = _this._register(workerFactory.create('vs/base/common/worker/simpleWorker', function (msg) {\r\n            _this._protocol.handleMessage(msg);\r\n        }, function (err) {\r\n            // in Firefox, web workers fail lazily :(\r\n            // we will reject the proxy\r\n            if (lazyProxyReject) {\r\n                lazyProxyReject(err);\r\n            }\r\n        }));\r\n        _this._protocol = new SimpleWorkerProtocol({\r\n            sendMessage: function (msg, transfer) {\r\n                _this._worker.postMessage(msg, transfer);\r\n            },\r\n            handleMessage: function (method, args) {\r\n                if (typeof host[method] !== 'function') {\r\n                    return Promise.reject(new Error('Missing method ' + method + ' on main thread host.'));\r\n                }\r\n                try {\r\n                    return Promise.resolve(host[method].apply(host, args));\r\n                }\r\n                catch (e) {\r\n                    return Promise.reject(e);\r\n                }\r\n            }\r\n        });\r\n        _this._protocol.setWorkerId(_this._worker.getId());\r\n        // Gather loader configuration\r\n        var loaderConfiguration = null;\r\n        if (typeof self.require !== 'undefined' && typeof self.require.getConfig === 'function') {\r\n            // Get the configuration from the Monaco AMD Loader\r\n            loaderConfiguration = self.require.getConfig();\r\n        }\r\n        else if (typeof self.requirejs !== 'undefined') {\r\n            // Get the configuration from requirejs\r\n            loaderConfiguration = self.requirejs.s.contexts._.config;\r\n        }\r\n        var hostMethods = types.getAllMethodNames(host);\r\n        // Send initialize message\r\n        _this._onModuleLoaded = _this._protocol.sendMessage(INITIALIZE, [\r\n            _this._worker.getId(),\r\n            JSON.parse(JSON.stringify(loaderConfiguration)),\r\n            moduleId,\r\n            hostMethods,\r\n        ]);\r\n        // Create proxy to loaded code\r\n        var proxyMethodRequest = function (method, args) {\r\n            return _this._request(method, args);\r\n        };\r\n        _this._lazyProxy = new Promise(function (resolve, reject) {\r\n            lazyProxyReject = reject;\r\n            _this._onModuleLoaded.then(function (availableMethods) {\r\n                resolve(types.createProxyObject(availableMethods, proxyMethodRequest));\r\n            }, function (e) {\r\n                reject(e);\r\n                _this._onError('Worker failed to load ' + moduleId, e);\r\n            });\r\n        });\r\n        return _this;\r\n    }\r\n    SimpleWorkerClient.prototype.getProxyObject = function () {\r\n        return this._lazyProxy;\r\n    };\r\n    SimpleWorkerClient.prototype._request = function (method, args) {\r\n        var _this = this;\r\n        return new Promise(function (resolve, reject) {\r\n            _this._onModuleLoaded.then(function () {\r\n                _this._protocol.sendMessage(method, args).then(resolve, reject);\r\n            }, reject);\r\n        });\r\n    };\r\n    SimpleWorkerClient.prototype._onError = function (message, error) {\r\n        console.error(message);\r\n        console.info(error);\r\n    };\r\n    return SimpleWorkerClient;\r\n}(Disposable));\r\nexport { SimpleWorkerClient };\r\n/**\r\n * Worker side\r\n */\r\nvar SimpleWorkerServer = /** @class */ (function () {\r\n    function SimpleWorkerServer(postMessage, requestHandlerFactory) {\r\n        var _this = this;\r\n        this._requestHandlerFactory = requestHandlerFactory;\r\n        this._requestHandler = null;\r\n        this._protocol = new SimpleWorkerProtocol({\r\n            sendMessage: function (msg, transfer) {\r\n                postMessage(msg, transfer);\r\n            },\r\n            handleMessage: function (method, args) { return _this._handleMessage(method, args); }\r\n        });\r\n    }\r\n    SimpleWorkerServer.prototype.onmessage = function (msg) {\r\n        this._protocol.handleMessage(msg);\r\n    };\r\n    SimpleWorkerServer.prototype._handleMessage = function (method, args) {\r\n        if (method === INITIALIZE) {\r\n            return this.initialize(args[0], args[1], args[2], args[3]);\r\n        }\r\n        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\r\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\r\n        }\r\n        try {\r\n            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\r\n        }\r\n        catch (e) {\r\n            return Promise.reject(e);\r\n        }\r\n    };\r\n    SimpleWorkerServer.prototype.initialize = function (workerId, loaderConfig, moduleId, hostMethods) {\r\n        var _this = this;\r\n        this._protocol.setWorkerId(workerId);\r\n        var proxyMethodRequest = function (method, args) {\r\n            return _this._protocol.sendMessage(method, args);\r\n        };\r\n        var hostProxy = types.createProxyObject(hostMethods, proxyMethodRequest);\r\n        if (this._requestHandlerFactory) {\r\n            // static request handler\r\n            this._requestHandler = this._requestHandlerFactory(hostProxy);\r\n            return Promise.resolve(types.getAllMethodNames(this._requestHandler));\r\n        }\r\n        if (loaderConfig) {\r\n            // Remove 'baseUrl', handling it is beyond scope for now\r\n            if (typeof loaderConfig.baseUrl !== 'undefined') {\r\n                delete loaderConfig['baseUrl'];\r\n            }\r\n            if (typeof loaderConfig.paths !== 'undefined') {\r\n                if (typeof loaderConfig.paths.vs !== 'undefined') {\r\n                    delete loaderConfig.paths['vs'];\r\n                }\r\n            }\r\n            // Since this is in a web worker, enable catching errors\r\n            loaderConfig.catchError = true;\r\n            self.require.config(loaderConfig);\r\n        }\r\n        return new Promise(function (resolve, reject) {\r\n            // Use the global require to be sure to get the global config\r\n            self.require([moduleId], function (module) {\r\n                _this._requestHandler = module.create(hostProxy);\r\n                if (!_this._requestHandler) {\r\n                    reject(new Error(\"No RequestHandler!\"));\r\n                    return;\r\n                }\r\n                resolve(types.getAllMethodNames(_this._requestHandler));\r\n            }, reject);\r\n        });\r\n    };\r\n    return SimpleWorkerServer;\r\n}());\r\nexport { SimpleWorkerServer };\r\n/**\r\n * Called on the worker side\r\n */\r\nexport function create(postMessage) {\r\n    return new SimpleWorkerServer(postMessage, null);\r\n}\r\n","/**\r\n * Returns the last element of an array.\r\n * @param array The array.\r\n * @param n Which element from the end (default is zero).\r\n */\r\nexport function tail(array, n) {\r\n    if (n === void 0) { n = 0; }\r\n    return array[array.length - (1 + n)];\r\n}\r\nexport function tail2(arr) {\r\n    if (arr.length === 0) {\r\n        throw new Error('Invalid tail call');\r\n    }\r\n    return [arr.slice(0, arr.length - 1), arr[arr.length - 1]];\r\n}\r\nexport function equals(one, other, itemEquals) {\r\n    if (itemEquals === void 0) { itemEquals = function (a, b) { return a === b; }; }\r\n    if (one === other) {\r\n        return true;\r\n    }\r\n    if (!one || !other) {\r\n        return false;\r\n    }\r\n    if (one.length !== other.length) {\r\n        return false;\r\n    }\r\n    for (var i = 0, len = one.length; i < len; i++) {\r\n        if (!itemEquals(one[i], other[i])) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\nexport function binarySearch(array, key, comparator) {\r\n    var low = 0, high = array.length - 1;\r\n    while (low <= high) {\r\n        var mid = ((low + high) / 2) | 0;\r\n        var comp = comparator(array[mid], key);\r\n        if (comp < 0) {\r\n            low = mid + 1;\r\n        }\r\n        else if (comp > 0) {\r\n            high = mid - 1;\r\n        }\r\n        else {\r\n            return mid;\r\n        }\r\n    }\r\n    return -(low + 1);\r\n}\r\n/**\r\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\r\n * are located before all elements where p(x) is true.\r\n * @returns the least x for which p(x) is true or array.length if no element fullfills the given function.\r\n */\r\nexport function findFirstInSorted(array, p) {\r\n    var low = 0, high = array.length;\r\n    if (high === 0) {\r\n        return 0; // no children\r\n    }\r\n    while (low < high) {\r\n        var mid = Math.floor((low + high) / 2);\r\n        if (p(array[mid])) {\r\n            high = mid;\r\n        }\r\n        else {\r\n            low = mid + 1;\r\n        }\r\n    }\r\n    return low;\r\n}\r\n/**\r\n * Like `Array#sort` but always stable. Usually runs a little slower `than Array#sort`\r\n * so only use this when actually needing stable sort.\r\n */\r\nexport function mergeSort(data, compare) {\r\n    _sort(data, compare, 0, data.length - 1, []);\r\n    return data;\r\n}\r\nfunction _merge(a, compare, lo, mid, hi, aux) {\r\n    var leftIdx = lo, rightIdx = mid + 1;\r\n    for (var i = lo; i <= hi; i++) {\r\n        aux[i] = a[i];\r\n    }\r\n    for (var i = lo; i <= hi; i++) {\r\n        if (leftIdx > mid) {\r\n            // left side consumed\r\n            a[i] = aux[rightIdx++];\r\n        }\r\n        else if (rightIdx > hi) {\r\n            // right side consumed\r\n            a[i] = aux[leftIdx++];\r\n        }\r\n        else if (compare(aux[rightIdx], aux[leftIdx]) < 0) {\r\n            // right element is less -> comes first\r\n            a[i] = aux[rightIdx++];\r\n        }\r\n        else {\r\n            // left element comes first (less or equal)\r\n            a[i] = aux[leftIdx++];\r\n        }\r\n    }\r\n}\r\nfunction _sort(a, compare, lo, hi, aux) {\r\n    if (hi <= lo) {\r\n        return;\r\n    }\r\n    var mid = lo + ((hi - lo) / 2) | 0;\r\n    _sort(a, compare, lo, mid, aux);\r\n    _sort(a, compare, mid + 1, hi, aux);\r\n    if (compare(a[mid], a[mid + 1]) <= 0) {\r\n        // left and right are sorted and if the last-left element is less\r\n        // or equals than the first-right element there is nothing else\r\n        // to do\r\n        return;\r\n    }\r\n    _merge(a, compare, lo, mid, hi, aux);\r\n}\r\nexport function groupBy(data, compare) {\r\n    var result = [];\r\n    var currentGroup = undefined;\r\n    for (var _i = 0, _a = mergeSort(data.slice(0), compare); _i < _a.length; _i++) {\r\n        var element = _a[_i];\r\n        if (!currentGroup || compare(currentGroup[0], element) !== 0) {\r\n            currentGroup = [element];\r\n            result.push(currentGroup);\r\n        }\r\n        else {\r\n            currentGroup.push(element);\r\n        }\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * @returns New array with all falsy values removed. The original array IS NOT modified.\r\n */\r\nexport function coalesce(array) {\r\n    return array.filter(function (e) { return !!e; });\r\n}\r\n/**\r\n * @returns false if the provided object is an array and not empty.\r\n */\r\nexport function isFalsyOrEmpty(obj) {\r\n    return !Array.isArray(obj) || obj.length === 0;\r\n}\r\nexport function isNonEmptyArray(obj) {\r\n    return Array.isArray(obj) && obj.length > 0;\r\n}\r\n/**\r\n * Removes duplicates from the given array. The optional keyFn allows to specify\r\n * how elements are checked for equalness by returning a unique string for each.\r\n */\r\nexport function distinct(array, keyFn) {\r\n    if (!keyFn) {\r\n        return array.filter(function (element, position) {\r\n            return array.indexOf(element) === position;\r\n        });\r\n    }\r\n    var seen = Object.create(null);\r\n    return array.filter(function (elem) {\r\n        var key = keyFn(elem);\r\n        if (seen[key]) {\r\n            return false;\r\n        }\r\n        seen[key] = true;\r\n        return true;\r\n    });\r\n}\r\nexport function distinctES6(array) {\r\n    var seen = new Set();\r\n    return array.filter(function (element) {\r\n        if (seen.has(element)) {\r\n            return false;\r\n        }\r\n        seen.add(element);\r\n        return true;\r\n    });\r\n}\r\nexport function fromSet(set) {\r\n    var result = [];\r\n    set.forEach(function (o) { return result.push(o); });\r\n    return result;\r\n}\r\nexport function firstIndex(array, fn) {\r\n    for (var i = 0; i < array.length; i++) {\r\n        var element = array[i];\r\n        if (fn(element)) {\r\n            return i;\r\n        }\r\n    }\r\n    return -1;\r\n}\r\nexport function first(array, fn, notFoundValue) {\r\n    if (notFoundValue === void 0) { notFoundValue = undefined; }\r\n    var index = firstIndex(array, fn);\r\n    return index < 0 ? notFoundValue : array[index];\r\n}\r\nexport function firstOrDefault(array, notFoundValue) {\r\n    return array.length > 0 ? array[0] : notFoundValue;\r\n}\r\nexport function flatten(arr) {\r\n    var _a;\r\n    return (_a = []).concat.apply(_a, arr);\r\n}\r\nexport function range(arg, to) {\r\n    var from = typeof to === 'number' ? arg : 0;\r\n    if (typeof to === 'number') {\r\n        from = arg;\r\n    }\r\n    else {\r\n        from = 0;\r\n        to = arg;\r\n    }\r\n    var result = [];\r\n    if (from <= to) {\r\n        for (var i = from; i < to; i++) {\r\n            result.push(i);\r\n        }\r\n    }\r\n    else {\r\n        for (var i = from; i > to; i--) {\r\n            result.push(i);\r\n        }\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Insert `insertArr` inside `target` at `insertIndex`.\r\n * Please don't touch unless you understand https://jsperf.com/inserting-an-array-within-an-array\r\n */\r\nexport function arrayInsert(target, insertIndex, insertArr) {\r\n    var before = target.slice(0, insertIndex);\r\n    var after = target.slice(insertIndex);\r\n    return before.concat(insertArr, after);\r\n}\r\n/**\r\n * Pushes an element to the start of the array, if found.\r\n */\r\nexport function pushToStart(arr, value) {\r\n    var index = arr.indexOf(value);\r\n    if (index > -1) {\r\n        arr.splice(index, 1);\r\n        arr.unshift(value);\r\n    }\r\n}\r\n/**\r\n * Pushes an element to the end of the array, if found.\r\n */\r\nexport function pushToEnd(arr, value) {\r\n    var index = arr.indexOf(value);\r\n    if (index > -1) {\r\n        arr.splice(index, 1);\r\n        arr.push(value);\r\n    }\r\n}\r\nexport function find(arr, predicate) {\r\n    for (var i = 0; i < arr.length; i++) {\r\n        var element = arr[i];\r\n        if (predicate(element, i, arr)) {\r\n            return element;\r\n        }\r\n    }\r\n    return undefined;\r\n}\r\nexport function asArray(x) {\r\n    return Array.isArray(x) ? x : [x];\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\n/**\r\n * Represents information about a specific difference between two sequences.\r\n */\r\nvar DiffChange = /** @class */ (function () {\r\n    /**\r\n     * Constructs a new DiffChange with the given sequence information\r\n     * and content.\r\n     */\r\n    function DiffChange(originalStart, originalLength, modifiedStart, modifiedLength) {\r\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\r\n        this.originalStart = originalStart;\r\n        this.originalLength = originalLength;\r\n        this.modifiedStart = modifiedStart;\r\n        this.modifiedLength = modifiedLength;\r\n    }\r\n    /**\r\n     * The end point (exclusive) of the change in the original sequence.\r\n     */\r\n    DiffChange.prototype.getOriginalEnd = function () {\r\n        return this.originalStart + this.originalLength;\r\n    };\r\n    /**\r\n     * The end point (exclusive) of the change in the modified sequence.\r\n     */\r\n    DiffChange.prototype.getModifiedEnd = function () {\r\n        return this.modifiedStart + this.modifiedLength;\r\n    };\r\n    return DiffChange;\r\n}());\r\nexport { DiffChange };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\n/**\r\n * Return a hash value for an object.\r\n */\r\nexport function hash(obj, hashVal) {\r\n    if (hashVal === void 0) { hashVal = 0; }\r\n    switch (typeof obj) {\r\n        case 'object':\r\n            if (obj === null) {\r\n                return numberHash(349, hashVal);\r\n            }\r\n            else if (Array.isArray(obj)) {\r\n                return arrayHash(obj, hashVal);\r\n            }\r\n            return objectHash(obj, hashVal);\r\n        case 'string':\r\n            return stringHash(obj, hashVal);\r\n        case 'boolean':\r\n            return booleanHash(obj, hashVal);\r\n        case 'number':\r\n            return numberHash(obj, hashVal);\r\n        case 'undefined':\r\n            return numberHash(0, 937);\r\n        default:\r\n            return numberHash(0, 617);\r\n    }\r\n}\r\nfunction numberHash(val, initialHashVal) {\r\n    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32\r\n}\r\nfunction booleanHash(b, initialHashVal) {\r\n    return numberHash(b ? 433 : 863, initialHashVal);\r\n}\r\nexport function stringHash(s, hashVal) {\r\n    hashVal = numberHash(149417, hashVal);\r\n    for (var i = 0, length_1 = s.length; i < length_1; i++) {\r\n        hashVal = numberHash(s.charCodeAt(i), hashVal);\r\n    }\r\n    return hashVal;\r\n}\r\nfunction arrayHash(arr, initialHashVal) {\r\n    initialHashVal = numberHash(104579, initialHashVal);\r\n    return arr.reduce(function (hashVal, item) { return hash(item, hashVal); }, initialHashVal);\r\n}\r\nfunction objectHash(obj, initialHashVal) {\r\n    initialHashVal = numberHash(181387, initialHashVal);\r\n    return Object.keys(obj).sort().reduce(function (hashVal, key) {\r\n        hashVal = stringHash(key, hashVal);\r\n        return hash(obj[key], hashVal);\r\n    }, initialHashVal);\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { DiffChange } from './diffChange.js';\r\nimport { stringHash } from '../hash.js';\r\nvar StringDiffSequence = /** @class */ (function () {\r\n    function StringDiffSequence(source) {\r\n        this.source = source;\r\n    }\r\n    StringDiffSequence.prototype.getElements = function () {\r\n        var source = this.source;\r\n        var characters = new Int32Array(source.length);\r\n        for (var i = 0, len = source.length; i < len; i++) {\r\n            characters[i] = source.charCodeAt(i);\r\n        }\r\n        return characters;\r\n    };\r\n    return StringDiffSequence;\r\n}());\r\nexport { StringDiffSequence };\r\nexport function stringDiff(original, modified, pretty) {\r\n    return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;\r\n}\r\n//\r\n// The code below has been ported from a C# implementation in VS\r\n//\r\nvar Debug = /** @class */ (function () {\r\n    function Debug() {\r\n    }\r\n    Debug.Assert = function (condition, message) {\r\n        if (!condition) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n    return Debug;\r\n}());\r\nexport { Debug };\r\nvar MyArray = /** @class */ (function () {\r\n    function MyArray() {\r\n    }\r\n    /**\r\n     * Copies a range of elements from an Array starting at the specified source index and pastes\r\n     * them to another Array starting at the specified destination index. The length and the indexes\r\n     * are specified as 64-bit integers.\r\n     * sourceArray:\r\n     *\t\tThe Array that contains the data to copy.\r\n     * sourceIndex:\r\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\r\n     * destinationArray:\r\n     *\t\tThe Array that receives the data.\r\n     * destinationIndex:\r\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\r\n     * length:\r\n     *\t\tA 64-bit integer that represents the number of elements to copy.\r\n     */\r\n    MyArray.Copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\r\n        for (var i = 0; i < length; i++) {\r\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\r\n        }\r\n    };\r\n    MyArray.Copy2 = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\r\n        for (var i = 0; i < length; i++) {\r\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\r\n        }\r\n    };\r\n    return MyArray;\r\n}());\r\nexport { MyArray };\r\n/**\r\n * A utility class which helps to create the set of DiffChanges from\r\n * a difference operation. This class accepts original DiffElements and\r\n * modified DiffElements that are involved in a particular change. The\r\n * MarktNextChange() method can be called to mark the separation between\r\n * distinct changes. At the end, the Changes property can be called to retrieve\r\n * the constructed changes.\r\n */\r\nvar DiffChangeHelper = /** @class */ (function () {\r\n    /**\r\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\r\n     */\r\n    function DiffChangeHelper() {\r\n        this.m_changes = [];\r\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\r\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\r\n        this.m_originalCount = 0;\r\n        this.m_modifiedCount = 0;\r\n    }\r\n    /**\r\n     * Marks the beginning of the next change in the set of differences.\r\n     */\r\n    DiffChangeHelper.prototype.MarkNextChange = function () {\r\n        // Only add to the list if there is something to add\r\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\r\n            // Add the new change to our list\r\n            this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\r\n        }\r\n        // Reset for the next change\r\n        this.m_originalCount = 0;\r\n        this.m_modifiedCount = 0;\r\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\r\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\r\n    };\r\n    /**\r\n     * Adds the original element at the given position to the elements\r\n     * affected by the current change. The modified index gives context\r\n     * to the change position with respect to the original sequence.\r\n     * @param originalIndex The index of the original element to add.\r\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\r\n     */\r\n    DiffChangeHelper.prototype.AddOriginalElement = function (originalIndex, modifiedIndex) {\r\n        // The 'true' start index is the smallest of the ones we've seen\r\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\r\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\r\n        this.m_originalCount++;\r\n    };\r\n    /**\r\n     * Adds the modified element at the given position to the elements\r\n     * affected by the current change. The original index gives context\r\n     * to the change position with respect to the modified sequence.\r\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\r\n     * @param modifiedIndex The index of the modified element to add.\r\n     */\r\n    DiffChangeHelper.prototype.AddModifiedElement = function (originalIndex, modifiedIndex) {\r\n        // The 'true' start index is the smallest of the ones we've seen\r\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\r\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\r\n        this.m_modifiedCount++;\r\n    };\r\n    /**\r\n     * Retrieves all of the changes marked by the class.\r\n     */\r\n    DiffChangeHelper.prototype.getChanges = function () {\r\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\r\n            // Finish up on whatever is left\r\n            this.MarkNextChange();\r\n        }\r\n        return this.m_changes;\r\n    };\r\n    /**\r\n     * Retrieves all of the changes marked by the class in the reverse order\r\n     */\r\n    DiffChangeHelper.prototype.getReverseChanges = function () {\r\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\r\n            // Finish up on whatever is left\r\n            this.MarkNextChange();\r\n        }\r\n        this.m_changes.reverse();\r\n        return this.m_changes;\r\n    };\r\n    return DiffChangeHelper;\r\n}());\r\n/**\r\n * An implementation of the difference algorithm described in\r\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\r\n */\r\nvar LcsDiff = /** @class */ (function () {\r\n    /**\r\n     * Constructs the DiffFinder\r\n     */\r\n    function LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate) {\r\n        if (continueProcessingPredicate === void 0) { continueProcessingPredicate = null; }\r\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\r\n        var _a = LcsDiff._getElements(originalSequence), originalStringElements = _a[0], originalElementsOrHash = _a[1], originalHasStrings = _a[2];\r\n        var _b = LcsDiff._getElements(modifiedSequence), modifiedStringElements = _b[0], modifiedElementsOrHash = _b[1], modifiedHasStrings = _b[2];\r\n        this._hasStrings = (originalHasStrings && modifiedHasStrings);\r\n        this._originalStringElements = originalStringElements;\r\n        this._originalElementsOrHash = originalElementsOrHash;\r\n        this._modifiedStringElements = modifiedStringElements;\r\n        this._modifiedElementsOrHash = modifiedElementsOrHash;\r\n        this.m_forwardHistory = [];\r\n        this.m_reverseHistory = [];\r\n    }\r\n    LcsDiff._isStringArray = function (arr) {\r\n        return (arr.length > 0 && typeof arr[0] === 'string');\r\n    };\r\n    LcsDiff._getElements = function (sequence) {\r\n        var elements = sequence.getElements();\r\n        if (LcsDiff._isStringArray(elements)) {\r\n            var hashes = new Int32Array(elements.length);\r\n            for (var i = 0, len = elements.length; i < len; i++) {\r\n                hashes[i] = stringHash(elements[i], 0);\r\n            }\r\n            return [elements, hashes, true];\r\n        }\r\n        if (elements instanceof Int32Array) {\r\n            return [[], elements, false];\r\n        }\r\n        return [[], new Int32Array(elements), false];\r\n    };\r\n    LcsDiff.prototype.ElementsAreEqual = function (originalIndex, newIndex) {\r\n        if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {\r\n            return false;\r\n        }\r\n        return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);\r\n    };\r\n    LcsDiff.prototype.OriginalElementsAreEqual = function (index1, index2) {\r\n        if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {\r\n            return false;\r\n        }\r\n        return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);\r\n    };\r\n    LcsDiff.prototype.ModifiedElementsAreEqual = function (index1, index2) {\r\n        if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {\r\n            return false;\r\n        }\r\n        return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);\r\n    };\r\n    LcsDiff.prototype.ComputeDiff = function (pretty) {\r\n        return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);\r\n    };\r\n    /**\r\n     * Computes the differences between the original and modified input\r\n     * sequences on the bounded range.\r\n     * @returns An array of the differences between the two input sequences.\r\n     */\r\n    LcsDiff.prototype._ComputeDiff = function (originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\r\n        var quitEarlyArr = [false];\r\n        var changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\r\n        if (pretty) {\r\n            // We have to clean up the computed diff to be more intuitive\r\n            // but it turns out this cannot be done correctly until the entire set\r\n            // of diffs have been computed\r\n            changes = this.PrettifyChanges(changes);\r\n        }\r\n        return {\r\n            quitEarly: quitEarlyArr[0],\r\n            changes: changes\r\n        };\r\n    };\r\n    /**\r\n     * Private helper method which computes the differences on the bounded range\r\n     * recursively.\r\n     * @returns An array of the differences between the two input sequences.\r\n     */\r\n    LcsDiff.prototype.ComputeDiffRecursive = function (originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\r\n        quitEarlyArr[0] = false;\r\n        // Find the start of the differences\r\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\r\n            originalStart++;\r\n            modifiedStart++;\r\n        }\r\n        // Find the end of the differences\r\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\r\n            originalEnd--;\r\n            modifiedEnd--;\r\n        }\r\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\r\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\r\n            var changes = void 0;\r\n            if (modifiedStart <= modifiedEnd) {\r\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\r\n                // All insertions\r\n                changes = [\r\n                    new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\r\n                ];\r\n            }\r\n            else if (originalStart <= originalEnd) {\r\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\r\n                // All deletions\r\n                changes = [\r\n                    new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\r\n                ];\r\n            }\r\n            else {\r\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\r\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\r\n                // Identical sequences - No differences\r\n                changes = [];\r\n            }\r\n            return changes;\r\n        }\r\n        // This problem can be solved using the Divide-And-Conquer technique.\r\n        var midOriginalArr = [0];\r\n        var midModifiedArr = [0];\r\n        var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\r\n        var midOriginal = midOriginalArr[0];\r\n        var midModified = midModifiedArr[0];\r\n        if (result !== null) {\r\n            // Result is not-null when there was enough memory to compute the changes while\r\n            // searching for the recursion point\r\n            return result;\r\n        }\r\n        else if (!quitEarlyArr[0]) {\r\n            // We can break the problem down recursively by finding the changes in the\r\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\r\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\r\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\r\n            var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\r\n            var rightChanges = [];\r\n            if (!quitEarlyArr[0]) {\r\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\r\n            }\r\n            else {\r\n                // We did't have time to finish the first half, so we don't have time to compute this half.\r\n                // Consider the entire rest of the sequence different.\r\n                rightChanges = [\r\n                    new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\r\n                ];\r\n            }\r\n            return this.ConcatenateChanges(leftChanges, rightChanges);\r\n        }\r\n        // If we hit here, we quit early, and so can't return anything meaningful\r\n        return [\r\n            new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\r\n        ];\r\n    };\r\n    LcsDiff.prototype.WALKTRACE = function (diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\r\n        var forwardChanges = null;\r\n        var reverseChanges = null;\r\n        // First, walk backward through the forward diagonals history\r\n        var changeHelper = new DiffChangeHelper();\r\n        var diagonalMin = diagonalForwardStart;\r\n        var diagonalMax = diagonalForwardEnd;\r\n        var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\r\n        var lastOriginalIndex = -1073741824 /* MIN_SAFE_SMALL_INTEGER */;\r\n        var historyIndex = this.m_forwardHistory.length - 1;\r\n        do {\r\n            // Get the diagonal index from the relative diagonal number\r\n            var diagonal = diagonalRelative + diagonalForwardBase;\r\n            // Figure out where we came from\r\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\r\n                // Vertical line (the element is an insert)\r\n                originalIndex = forwardPoints[diagonal + 1];\r\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\r\n                if (originalIndex < lastOriginalIndex) {\r\n                    changeHelper.MarkNextChange();\r\n                }\r\n                lastOriginalIndex = originalIndex;\r\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\r\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\r\n            }\r\n            else {\r\n                // Horizontal line (the element is a deletion)\r\n                originalIndex = forwardPoints[diagonal - 1] + 1;\r\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\r\n                if (originalIndex < lastOriginalIndex) {\r\n                    changeHelper.MarkNextChange();\r\n                }\r\n                lastOriginalIndex = originalIndex - 1;\r\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\r\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\r\n            }\r\n            if (historyIndex >= 0) {\r\n                forwardPoints = this.m_forwardHistory[historyIndex];\r\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\r\n                diagonalMin = 1;\r\n                diagonalMax = forwardPoints.length - 1;\r\n            }\r\n        } while (--historyIndex >= -1);\r\n        // Ironically, we get the forward changes as the reverse of the\r\n        // order we added them since we technically added them backwards\r\n        forwardChanges = changeHelper.getReverseChanges();\r\n        if (quitEarlyArr[0]) {\r\n            // TODO: Calculate a partial from the reverse diagonals.\r\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\r\n            var originalStartPoint = midOriginalArr[0] + 1;\r\n            var modifiedStartPoint = midModifiedArr[0] + 1;\r\n            if (forwardChanges !== null && forwardChanges.length > 0) {\r\n                var lastForwardChange = forwardChanges[forwardChanges.length - 1];\r\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\r\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\r\n            }\r\n            reverseChanges = [\r\n                new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\r\n            ];\r\n        }\r\n        else {\r\n            // Now walk backward through the reverse diagonals history\r\n            changeHelper = new DiffChangeHelper();\r\n            diagonalMin = diagonalReverseStart;\r\n            diagonalMax = diagonalReverseEnd;\r\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\r\n            lastOriginalIndex = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\r\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\r\n            do {\r\n                // Get the diagonal index from the relative diagonal number\r\n                var diagonal = diagonalRelative + diagonalReverseBase;\r\n                // Figure out where we came from\r\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\r\n                    // Horizontal line (the element is a deletion))\r\n                    originalIndex = reversePoints[diagonal + 1] - 1;\r\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\r\n                    if (originalIndex > lastOriginalIndex) {\r\n                        changeHelper.MarkNextChange();\r\n                    }\r\n                    lastOriginalIndex = originalIndex + 1;\r\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\r\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\r\n                }\r\n                else {\r\n                    // Vertical line (the element is an insertion)\r\n                    originalIndex = reversePoints[diagonal - 1];\r\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\r\n                    if (originalIndex > lastOriginalIndex) {\r\n                        changeHelper.MarkNextChange();\r\n                    }\r\n                    lastOriginalIndex = originalIndex;\r\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\r\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\r\n                }\r\n                if (historyIndex >= 0) {\r\n                    reversePoints = this.m_reverseHistory[historyIndex];\r\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\r\n                    diagonalMin = 1;\r\n                    diagonalMax = reversePoints.length - 1;\r\n                }\r\n            } while (--historyIndex >= -1);\r\n            // There are cases where the reverse history will find diffs that\r\n            // are correct, but not intuitive, so we need shift them.\r\n            reverseChanges = changeHelper.getChanges();\r\n        }\r\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\r\n    };\r\n    /**\r\n     * Given the range to compute the diff on, this method finds the point:\r\n     * (midOriginal, midModified)\r\n     * that exists in the middle of the LCS of the two sequences and\r\n     * is the point at which the LCS problem may be broken down recursively.\r\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\r\n     * point is calculated and the full trace is available in memory, then this method\r\n     * will return the change list.\r\n     * @param originalStart The start bound of the original sequence range\r\n     * @param originalEnd The end bound of the original sequence range\r\n     * @param modifiedStart The start bound of the modified sequence range\r\n     * @param modifiedEnd The end bound of the modified sequence range\r\n     * @param midOriginal The middle point of the original sequence range\r\n     * @param midModified The middle point of the modified sequence range\r\n     * @returns The diff changes, if available, otherwise null\r\n     */\r\n    LcsDiff.prototype.ComputeRecursionPoint = function (originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\r\n        var originalIndex = 0, modifiedIndex = 0;\r\n        var diagonalForwardStart = 0, diagonalForwardEnd = 0;\r\n        var diagonalReverseStart = 0, diagonalReverseEnd = 0;\r\n        // To traverse the edit graph and produce the proper LCS, our actual\r\n        // start position is just outside the given boundary\r\n        originalStart--;\r\n        modifiedStart--;\r\n        // We set these up to make the compiler happy, but they will\r\n        // be replaced before we return with the actual recursion point\r\n        midOriginalArr[0] = 0;\r\n        midModifiedArr[0] = 0;\r\n        // Clear out the history\r\n        this.m_forwardHistory = [];\r\n        this.m_reverseHistory = [];\r\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\r\n        // The integer value in the cell represents the originalIndex of the furthest\r\n        // reaching point found so far that ends in that diagonal.\r\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\r\n        var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\r\n        var numDiagonals = maxDifferences + 1;\r\n        var forwardPoints = new Int32Array(numDiagonals);\r\n        var reversePoints = new Int32Array(numDiagonals);\r\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\r\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\r\n        var diagonalForwardBase = (modifiedEnd - modifiedStart);\r\n        var diagonalReverseBase = (originalEnd - originalStart);\r\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\r\n        //    diagonal number (relative to diagonalForwardBase)\r\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\r\n        //    diagonal number (relative to diagonalReverseBase)\r\n        var diagonalForwardOffset = (originalStart - modifiedStart);\r\n        var diagonalReverseOffset = (originalEnd - modifiedEnd);\r\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\r\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\r\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\r\n        var delta = diagonalReverseBase - diagonalForwardBase;\r\n        var deltaIsEven = (delta % 2 === 0);\r\n        // Here we set up the start and end points as the furthest points found so far\r\n        // in both the forward and reverse directions, respectively\r\n        forwardPoints[diagonalForwardBase] = originalStart;\r\n        reversePoints[diagonalReverseBase] = originalEnd;\r\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\r\n        quitEarlyArr[0] = false;\r\n        // A couple of points:\r\n        // --With this method, we iterate on the number of differences between the two sequences.\r\n        //   The more differences there actually are, the longer this will take.\r\n        // --Also, as the number of differences increases, we have to search on diagonals further\r\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\r\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\r\n        //   is even and odd diagonals only when numDifferences is odd.\r\n        for (var numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\r\n            var furthestOriginalIndex = 0;\r\n            var furthestModifiedIndex = 0;\r\n            // Run the algorithm in the forward direction\r\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\r\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\r\n            for (var diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\r\n                // STEP 1: We extend the furthest reaching point in the present diagonal\r\n                // by looking at the diagonals above and below and picking the one whose point\r\n                // is further away from the start point (originalStart, modifiedStart)\r\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\r\n                    originalIndex = forwardPoints[diagonal + 1];\r\n                }\r\n                else {\r\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\r\n                }\r\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\r\n                // Save the current originalIndex so we can test for false overlap in step 3\r\n                var tempOriginalIndex = originalIndex;\r\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\r\n                // so long as the elements are equal.\r\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\r\n                    originalIndex++;\r\n                    modifiedIndex++;\r\n                }\r\n                forwardPoints[diagonal] = originalIndex;\r\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\r\n                    furthestOriginalIndex = originalIndex;\r\n                    furthestModifiedIndex = modifiedIndex;\r\n                }\r\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\r\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\r\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\r\n                // then check for overlap.\r\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\r\n                    if (originalIndex >= reversePoints[diagonal]) {\r\n                        midOriginalArr[0] = originalIndex;\r\n                        midModifiedArr[0] = modifiedIndex;\r\n                        if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\r\n                            // BINGO! We overlapped, and we have the full trace in memory!\r\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\r\n                        }\r\n                        else {\r\n                            // Either false overlap, or we didn't have enough memory for the full trace\r\n                            // Just return the recursion point\r\n                            return null;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Check to see if we should be quitting early, before moving on to the next iteration.\r\n            var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\r\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {\r\n                // We can't finish, so skip ahead to generating a result from what we have.\r\n                quitEarlyArr[0] = true;\r\n                // Use the furthest distance we got in the forward direction.\r\n                midOriginalArr[0] = furthestOriginalIndex;\r\n                midModifiedArr[0] = furthestModifiedIndex;\r\n                if (matchLengthOfLongest > 0 && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\r\n                    // Enough of the history is in memory to walk it backwards\r\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\r\n                }\r\n                else {\r\n                    // We didn't actually remember enough of the history.\r\n                    //Since we are quiting the diff early, we need to shift back the originalStart and modified start\r\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\r\n                    originalStart++;\r\n                    modifiedStart++;\r\n                    return [\r\n                        new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\r\n                    ];\r\n                }\r\n            }\r\n            // Run the algorithm in the reverse direction\r\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\r\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\r\n            for (var diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\r\n                // STEP 1: We extend the furthest reaching point in the present diagonal\r\n                // by looking at the diagonals above and below and picking the one whose point\r\n                // is further away from the start point (originalEnd, modifiedEnd)\r\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\r\n                    originalIndex = reversePoints[diagonal + 1] - 1;\r\n                }\r\n                else {\r\n                    originalIndex = reversePoints[diagonal - 1];\r\n                }\r\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\r\n                // Save the current originalIndex so we can test for false overlap\r\n                var tempOriginalIndex = originalIndex;\r\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\r\n                // as long as the elements are equal.\r\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\r\n                    originalIndex--;\r\n                    modifiedIndex--;\r\n                }\r\n                reversePoints[diagonal] = originalIndex;\r\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\r\n                // and diagonal is in the range of forward diagonals computed for numDifferences\r\n                // then check for overlap.\r\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\r\n                    if (originalIndex <= forwardPoints[diagonal]) {\r\n                        midOriginalArr[0] = originalIndex;\r\n                        midModifiedArr[0] = modifiedIndex;\r\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\r\n                            // BINGO! We overlapped, and we have the full trace in memory!\r\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\r\n                        }\r\n                        else {\r\n                            // Either false overlap, or we didn't have enough memory for the full trace\r\n                            // Just return the recursion point\r\n                            return null;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            // Save current vectors to history before the next iteration\r\n            if (numDifferences <= 1447 /* MaxDifferencesHistory */) {\r\n                // We are allocating space for one extra int, which we fill with\r\n                // the index of the diagonal base index\r\n                var temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);\r\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\r\n                MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\r\n                this.m_forwardHistory.push(temp);\r\n                temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);\r\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\r\n                MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\r\n                this.m_reverseHistory.push(temp);\r\n            }\r\n        }\r\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\r\n        // NOTE: This part is a bit messy\r\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\r\n    };\r\n    /**\r\n     * Shifts the given changes to provide a more intuitive diff.\r\n     * While the first element in a diff matches the first element after the diff,\r\n     * we shift the diff down.\r\n     *\r\n     * @param changes The list of changes to shift\r\n     * @returns The shifted changes\r\n     */\r\n    LcsDiff.prototype.PrettifyChanges = function (changes) {\r\n        // Shift all the changes down first\r\n        for (var i = 0; i < changes.length; i++) {\r\n            var change = changes[i];\r\n            var originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;\r\n            var modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;\r\n            var checkOriginal = change.originalLength > 0;\r\n            var checkModified = change.modifiedLength > 0;\r\n            while (change.originalStart + change.originalLength < originalStop &&\r\n                change.modifiedStart + change.modifiedLength < modifiedStop &&\r\n                (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) &&\r\n                (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\r\n                change.originalStart++;\r\n                change.modifiedStart++;\r\n            }\r\n            var mergedChangeArr = [null];\r\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\r\n                changes[i] = mergedChangeArr[0];\r\n                changes.splice(i + 1, 1);\r\n                i--;\r\n                continue;\r\n            }\r\n        }\r\n        // Shift changes back up until we hit empty or whitespace-only lines\r\n        for (var i = changes.length - 1; i >= 0; i--) {\r\n            var change = changes[i];\r\n            var originalStop = 0;\r\n            var modifiedStop = 0;\r\n            if (i > 0) {\r\n                var prevChange = changes[i - 1];\r\n                if (prevChange.originalLength > 0) {\r\n                    originalStop = prevChange.originalStart + prevChange.originalLength;\r\n                }\r\n                if (prevChange.modifiedLength > 0) {\r\n                    modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\r\n                }\r\n            }\r\n            var checkOriginal = change.originalLength > 0;\r\n            var checkModified = change.modifiedLength > 0;\r\n            var bestDelta = 0;\r\n            var bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\r\n            for (var delta = 1;; delta++) {\r\n                var originalStart = change.originalStart - delta;\r\n                var modifiedStart = change.modifiedStart - delta;\r\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\r\n                    break;\r\n                }\r\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\r\n                    break;\r\n                }\r\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\r\n                    break;\r\n                }\r\n                var score = this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength);\r\n                if (score > bestScore) {\r\n                    bestScore = score;\r\n                    bestDelta = delta;\r\n                }\r\n            }\r\n            change.originalStart -= bestDelta;\r\n            change.modifiedStart -= bestDelta;\r\n        }\r\n        return changes;\r\n    };\r\n    LcsDiff.prototype._OriginalIsBoundary = function (index) {\r\n        if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {\r\n            return true;\r\n        }\r\n        return (this._hasStrings && /^\\s*$/.test(this._originalStringElements[index]));\r\n    };\r\n    LcsDiff.prototype._OriginalRegionIsBoundary = function (originalStart, originalLength) {\r\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\r\n            return true;\r\n        }\r\n        if (originalLength > 0) {\r\n            var originalEnd = originalStart + originalLength;\r\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    };\r\n    LcsDiff.prototype._ModifiedIsBoundary = function (index) {\r\n        if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {\r\n            return true;\r\n        }\r\n        return (this._hasStrings && /^\\s*$/.test(this._modifiedStringElements[index]));\r\n    };\r\n    LcsDiff.prototype._ModifiedRegionIsBoundary = function (modifiedStart, modifiedLength) {\r\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\r\n            return true;\r\n        }\r\n        if (modifiedLength > 0) {\r\n            var modifiedEnd = modifiedStart + modifiedLength;\r\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    };\r\n    LcsDiff.prototype._boundaryScore = function (originalStart, originalLength, modifiedStart, modifiedLength) {\r\n        var originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\r\n        var modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\r\n        return (originalScore + modifiedScore);\r\n    };\r\n    /**\r\n     * Concatenates the two input DiffChange lists and returns the resulting\r\n     * list.\r\n     * @param The left changes\r\n     * @param The right changes\r\n     * @returns The concatenated list\r\n     */\r\n    LcsDiff.prototype.ConcatenateChanges = function (left, right) {\r\n        var mergedChangeArr = [];\r\n        if (left.length === 0 || right.length === 0) {\r\n            return (right.length > 0) ? right : left;\r\n        }\r\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\r\n            // Since we break the problem down recursively, it is possible that we\r\n            // might recurse in the middle of a change thereby splitting it into\r\n            // two changes. Here in the combining stage, we detect and fuse those\r\n            // changes back together\r\n            var result = new Array(left.length + right.length - 1);\r\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\r\n            result[left.length - 1] = mergedChangeArr[0];\r\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\r\n            return result;\r\n        }\r\n        else {\r\n            var result = new Array(left.length + right.length);\r\n            MyArray.Copy(left, 0, result, 0, left.length);\r\n            MyArray.Copy(right, 0, result, left.length, right.length);\r\n            return result;\r\n        }\r\n    };\r\n    /**\r\n     * Returns true if the two changes overlap and can be merged into a single\r\n     * change\r\n     * @param left The left change\r\n     * @param right The right change\r\n     * @param mergedChange The merged change if the two overlap, null otherwise\r\n     * @returns True if the two changes overlap\r\n     */\r\n    LcsDiff.prototype.ChangesOverlap = function (left, right, mergedChangeArr) {\r\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\r\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\r\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\r\n            var originalStart = left.originalStart;\r\n            var originalLength = left.originalLength;\r\n            var modifiedStart = left.modifiedStart;\r\n            var modifiedLength = left.modifiedLength;\r\n            if (left.originalStart + left.originalLength >= right.originalStart) {\r\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\r\n            }\r\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\r\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\r\n            }\r\n            mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\r\n            return true;\r\n        }\r\n        else {\r\n            mergedChangeArr[0] = null;\r\n            return false;\r\n        }\r\n    };\r\n    /**\r\n     * Helper method used to clip a diagonal index to the range of valid\r\n     * diagonals. This also decides whether or not the diagonal index,\r\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\r\n     * one inside the boundary depending on the Even/Odd status of the boundary\r\n     * and numDifferences.\r\n     * @param diagonal The index of the diagonal to clip.\r\n     * @param numDifferences The current number of differences being iterated upon.\r\n     * @param diagonalBaseIndex The base reference diagonal.\r\n     * @param numDiagonals The total number of diagonals.\r\n     * @returns The clipped diagonal index.\r\n     */\r\n    LcsDiff.prototype.ClipDiagonalBound = function (diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\r\n        if (diagonal >= 0 && diagonal < numDiagonals) {\r\n            // Nothing to clip, its in range\r\n            return diagonal;\r\n        }\r\n        // diagonalsBelow: The number of diagonals below the reference diagonal\r\n        // diagonalsAbove: The number of diagonals above the reference diagonal\r\n        var diagonalsBelow = diagonalBaseIndex;\r\n        var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\r\n        var diffEven = (numDifferences % 2 === 0);\r\n        if (diagonal < 0) {\r\n            var lowerBoundEven = (diagonalsBelow % 2 === 0);\r\n            return (diffEven === lowerBoundEven) ? 0 : 1;\r\n        }\r\n        else {\r\n            var upperBoundEven = (diagonalsAbove % 2 === 0);\r\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\r\n        }\r\n    };\r\n    return LcsDiff;\r\n}());\r\nexport { LcsDiff };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nexport var FIN = { done: true, value: undefined };\r\nexport var Iterator;\r\n(function (Iterator) {\r\n    var _empty = {\r\n        next: function () {\r\n            return FIN;\r\n        }\r\n    };\r\n    function empty() {\r\n        return _empty;\r\n    }\r\n    Iterator.empty = empty;\r\n    function single(value) {\r\n        var done = false;\r\n        return {\r\n            next: function () {\r\n                if (done) {\r\n                    return FIN;\r\n                }\r\n                done = true;\r\n                return { done: false, value: value };\r\n            }\r\n        };\r\n    }\r\n    Iterator.single = single;\r\n    function fromArray(array, index, length) {\r\n        if (index === void 0) { index = 0; }\r\n        if (length === void 0) { length = array.length; }\r\n        return {\r\n            next: function () {\r\n                if (index >= length) {\r\n                    return FIN;\r\n                }\r\n                return { done: false, value: array[index++] };\r\n            }\r\n        };\r\n    }\r\n    Iterator.fromArray = fromArray;\r\n    function fromNativeIterator(it) {\r\n        return {\r\n            next: function () {\r\n                var result = it.next();\r\n                if (result.done) {\r\n                    return FIN;\r\n                }\r\n                return { done: false, value: result.value };\r\n            }\r\n        };\r\n    }\r\n    Iterator.fromNativeIterator = fromNativeIterator;\r\n    function from(elements) {\r\n        if (!elements) {\r\n            return Iterator.empty();\r\n        }\r\n        else if (Array.isArray(elements)) {\r\n            return Iterator.fromArray(elements);\r\n        }\r\n        else {\r\n            return elements;\r\n        }\r\n    }\r\n    Iterator.from = from;\r\n    function map(iterator, fn) {\r\n        return {\r\n            next: function () {\r\n                var element = iterator.next();\r\n                if (element.done) {\r\n                    return FIN;\r\n                }\r\n                else {\r\n                    return { done: false, value: fn(element.value) };\r\n                }\r\n            }\r\n        };\r\n    }\r\n    Iterator.map = map;\r\n    function filter(iterator, fn) {\r\n        return {\r\n            next: function () {\r\n                while (true) {\r\n                    var element = iterator.next();\r\n                    if (element.done) {\r\n                        return FIN;\r\n                    }\r\n                    if (fn(element.value)) {\r\n                        return { done: false, value: element.value };\r\n                    }\r\n                }\r\n            }\r\n        };\r\n    }\r\n    Iterator.filter = filter;\r\n    function forEach(iterator, fn) {\r\n        for (var next = iterator.next(); !next.done; next = iterator.next()) {\r\n            fn(next.value);\r\n        }\r\n    }\r\n    Iterator.forEach = forEach;\r\n    function collect(iterator, atMost) {\r\n        if (atMost === void 0) { atMost = Number.POSITIVE_INFINITY; }\r\n        var result = [];\r\n        if (atMost === 0) {\r\n            return result;\r\n        }\r\n        var i = 0;\r\n        for (var next = iterator.next(); !next.done; next = iterator.next()) {\r\n            result.push(next.value);\r\n            if (++i >= atMost) {\r\n                break;\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n    Iterator.collect = collect;\r\n    function concat() {\r\n        var iterators = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            iterators[_i] = arguments[_i];\r\n        }\r\n        var i = 0;\r\n        return {\r\n            next: function () {\r\n                if (i >= iterators.length) {\r\n                    return FIN;\r\n                }\r\n                var iterator = iterators[i];\r\n                var result = iterator.next();\r\n                if (result.done) {\r\n                    i++;\r\n                    return this.next();\r\n                }\r\n                return result;\r\n            }\r\n        };\r\n    }\r\n    Iterator.concat = concat;\r\n    function chain(iterator) {\r\n        return new ChainableIterator(iterator);\r\n    }\r\n    Iterator.chain = chain;\r\n})(Iterator || (Iterator = {}));\r\nvar ChainableIterator = /** @class */ (function () {\r\n    function ChainableIterator(it) {\r\n        this.it = it;\r\n    }\r\n    ChainableIterator.prototype.next = function () { return this.it.next(); };\r\n    return ChainableIterator;\r\n}());\r\nexport { ChainableIterator };\r\nexport function getSequenceIterator(arg) {\r\n    if (Array.isArray(arg)) {\r\n        return Iterator.fromArray(arg);\r\n    }\r\n    else if (!arg) {\r\n        return Iterator.empty();\r\n    }\r\n    else {\r\n        return arg;\r\n    }\r\n}\r\nvar ArrayIterator = /** @class */ (function () {\r\n    function ArrayIterator(items, start, end, index) {\r\n        if (start === void 0) { start = 0; }\r\n        if (end === void 0) { end = items.length; }\r\n        if (index === void 0) { index = start - 1; }\r\n        this.items = items;\r\n        this.start = start;\r\n        this.end = end;\r\n        this.index = index;\r\n    }\r\n    ArrayIterator.prototype.first = function () {\r\n        this.index = this.start;\r\n        return this.current();\r\n    };\r\n    ArrayIterator.prototype.next = function () {\r\n        this.index = Math.min(this.index + 1, this.end);\r\n        return this.current();\r\n    };\r\n    ArrayIterator.prototype.current = function () {\r\n        if (this.index === this.start - 1 || this.index === this.end) {\r\n            return null;\r\n        }\r\n        return this.items[this.index];\r\n    };\r\n    return ArrayIterator;\r\n}());\r\nexport { ArrayIterator };\r\nvar ArrayNavigator = /** @class */ (function (_super) {\r\n    __extends(ArrayNavigator, _super);\r\n    function ArrayNavigator(items, start, end, index) {\r\n        if (start === void 0) { start = 0; }\r\n        if (end === void 0) { end = items.length; }\r\n        if (index === void 0) { index = start - 1; }\r\n        return _super.call(this, items, start, end, index) || this;\r\n    }\r\n    ArrayNavigator.prototype.current = function () {\r\n        return _super.prototype.current.call(this);\r\n    };\r\n    ArrayNavigator.prototype.previous = function () {\r\n        this.index = Math.max(this.index - 1, this.start - 1);\r\n        return this.current();\r\n    };\r\n    ArrayNavigator.prototype.first = function () {\r\n        this.index = this.start;\r\n        return this.current();\r\n    };\r\n    ArrayNavigator.prototype.last = function () {\r\n        this.index = this.end - 1;\r\n        return this.current();\r\n    };\r\n    ArrayNavigator.prototype.parent = function () {\r\n        return null;\r\n    };\r\n    return ArrayNavigator;\r\n}(ArrayIterator));\r\nexport { ArrayNavigator };\r\nvar MappedIterator = /** @class */ (function () {\r\n    function MappedIterator(iterator, fn) {\r\n        this.iterator = iterator;\r\n        this.fn = fn;\r\n        // noop\r\n    }\r\n    MappedIterator.prototype.next = function () { return this.fn(this.iterator.next()); };\r\n    return MappedIterator;\r\n}());\r\nexport { MappedIterator };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nvar _a;\r\nimport { isWindows } from './platform.js';\r\nvar _schemePattern = /^\\w[\\w\\d+.-]*$/;\r\nvar _singleSlashStart = /^\\//;\r\nvar _doubleSlashStart = /^\\/\\//;\r\nfunction _validateUri(ret, _strict) {\r\n    // scheme, must be set\r\n    if (!ret.scheme && _strict) {\r\n        throw new Error(\"[UriError]: Scheme is missing: {scheme: \\\"\\\", authority: \\\"\" + ret.authority + \"\\\", path: \\\"\" + ret.path + \"\\\", query: \\\"\" + ret.query + \"\\\", fragment: \\\"\" + ret.fragment + \"\\\"}\");\r\n    }\r\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\r\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\r\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\r\n        throw new Error('[UriError]: Scheme contains illegal characters.');\r\n    }\r\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\r\n    // If a URI contains an authority component, then the path component\r\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\r\n    // does not contain an authority component, then the path cannot begin\r\n    // with two slash characters (\"//\").\r\n    if (ret.path) {\r\n        if (ret.authority) {\r\n            if (!_singleSlashStart.test(ret.path)) {\r\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');\r\n            }\r\n        }\r\n        else {\r\n            if (_doubleSlashStart.test(ret.path)) {\r\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\r\n            }\r\n        }\r\n    }\r\n}\r\n// for a while we allowed uris *without* schemes and this is the migration\r\n// for them, e.g. an uri without scheme and without strict-mode warns and falls\r\n// back to the file-scheme. that should cause the least carnage and still be a\r\n// clear warning\r\nfunction _schemeFix(scheme, _strict) {\r\n    if (!scheme && !_strict) {\r\n        return 'file';\r\n    }\r\n    return scheme;\r\n}\r\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\r\nfunction _referenceResolution(scheme, path) {\r\n    // the slash-character is our 'default base' as we don't\r\n    // support constructing URIs relative to other URIs. This\r\n    // also means that we alter and potentially break paths.\r\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\r\n    switch (scheme) {\r\n        case 'https':\r\n        case 'http':\r\n        case 'file':\r\n            if (!path) {\r\n                path = _slash;\r\n            }\r\n            else if (path[0] !== _slash) {\r\n                path = _slash + path;\r\n            }\r\n            break;\r\n    }\r\n    return path;\r\n}\r\nvar _empty = '';\r\nvar _slash = '/';\r\nvar _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\r\n/**\r\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\r\n * This class is a simple parser which creates the basic component parts\r\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\r\n * and encoding.\r\n *\r\n *       foo://example.com:8042/over/there?name=ferret#nose\r\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\r\n *        |           |            |            |        |\r\n *     scheme     authority       path        query   fragment\r\n *        |   _____________________|__\r\n *       / \\ /                        \\\r\n *       urn:example:animal:ferret:nose\r\n */\r\nvar URI = /** @class */ (function () {\r\n    /**\r\n     * @internal\r\n     */\r\n    function URI(schemeOrData, authority, path, query, fragment, _strict) {\r\n        if (_strict === void 0) { _strict = false; }\r\n        if (typeof schemeOrData === 'object') {\r\n            this.scheme = schemeOrData.scheme || _empty;\r\n            this.authority = schemeOrData.authority || _empty;\r\n            this.path = schemeOrData.path || _empty;\r\n            this.query = schemeOrData.query || _empty;\r\n            this.fragment = schemeOrData.fragment || _empty;\r\n            // no validation because it's this URI\r\n            // that creates uri components.\r\n            // _validateUri(this);\r\n        }\r\n        else {\r\n            this.scheme = _schemeFix(schemeOrData, _strict);\r\n            this.authority = authority || _empty;\r\n            this.path = _referenceResolution(this.scheme, path || _empty);\r\n            this.query = query || _empty;\r\n            this.fragment = fragment || _empty;\r\n            _validateUri(this, _strict);\r\n        }\r\n    }\r\n    URI.isUri = function (thing) {\r\n        if (thing instanceof URI) {\r\n            return true;\r\n        }\r\n        if (!thing) {\r\n            return false;\r\n        }\r\n        return typeof thing.authority === 'string'\r\n            && typeof thing.fragment === 'string'\r\n            && typeof thing.path === 'string'\r\n            && typeof thing.query === 'string'\r\n            && typeof thing.scheme === 'string'\r\n            && typeof thing.fsPath === 'function'\r\n            && typeof thing.with === 'function'\r\n            && typeof thing.toString === 'function';\r\n    };\r\n    Object.defineProperty(URI.prototype, \"fsPath\", {\r\n        // ---- filesystem path -----------------------\r\n        /**\r\n         * Returns a string representing the corresponding file system path of this URI.\r\n         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\r\n         * platform specific path separator.\r\n         *\r\n         * * Will *not* validate the path for invalid characters and semantics.\r\n         * * Will *not* look at the scheme of this URI.\r\n         * * The result shall *not* be used for display purposes but for accessing a file on disk.\r\n         *\r\n         *\r\n         * The *difference* to `URI#path` is the use of the platform specific separator and the handling\r\n         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\r\n         *\r\n         * ```ts\r\n            const u = URI.parse('file://server/c$/folder/file.txt')\r\n            u.authority === 'server'\r\n            u.path === '/shares/c$/file.txt'\r\n            u.fsPath === '\\\\server\\c$\\folder\\file.txt'\r\n        ```\r\n         *\r\n         * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\r\n         * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\r\n         * with URIs that represent files on disk (`file` scheme).\r\n         */\r\n        get: function () {\r\n            // if (this.scheme !== 'file') {\r\n            // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\r\n            // }\r\n            return _makeFsPath(this);\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    // ---- modify to new -------------------------\r\n    URI.prototype.with = function (change) {\r\n        if (!change) {\r\n            return this;\r\n        }\r\n        var scheme = change.scheme, authority = change.authority, path = change.path, query = change.query, fragment = change.fragment;\r\n        if (scheme === undefined) {\r\n            scheme = this.scheme;\r\n        }\r\n        else if (scheme === null) {\r\n            scheme = _empty;\r\n        }\r\n        if (authority === undefined) {\r\n            authority = this.authority;\r\n        }\r\n        else if (authority === null) {\r\n            authority = _empty;\r\n        }\r\n        if (path === undefined) {\r\n            path = this.path;\r\n        }\r\n        else if (path === null) {\r\n            path = _empty;\r\n        }\r\n        if (query === undefined) {\r\n            query = this.query;\r\n        }\r\n        else if (query === null) {\r\n            query = _empty;\r\n        }\r\n        if (fragment === undefined) {\r\n            fragment = this.fragment;\r\n        }\r\n        else if (fragment === null) {\r\n            fragment = _empty;\r\n        }\r\n        if (scheme === this.scheme\r\n            && authority === this.authority\r\n            && path === this.path\r\n            && query === this.query\r\n            && fragment === this.fragment) {\r\n            return this;\r\n        }\r\n        return new _URI(scheme, authority, path, query, fragment);\r\n    };\r\n    // ---- parse & validate ------------------------\r\n    /**\r\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\r\n     * `file:///usr/home`, or `scheme:with/path`.\r\n     *\r\n     * @param value A string which represents an URI (see `URI#toString`).\r\n     */\r\n    URI.parse = function (value, _strict) {\r\n        if (_strict === void 0) { _strict = false; }\r\n        var match = _regexp.exec(value);\r\n        if (!match) {\r\n            return new _URI(_empty, _empty, _empty, _empty, _empty);\r\n        }\r\n        return new _URI(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);\r\n    };\r\n    /**\r\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\r\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\r\n     *\r\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\r\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\r\n     * `URI.parse('file://' + path)` because the path might contain characters that are\r\n     * interpreted (# and ?). See the following sample:\r\n     * ```ts\r\n    const good = URI.file('/coding/c#/project1');\r\n    good.scheme === 'file';\r\n    good.path === '/coding/c#/project1';\r\n    good.fragment === '';\r\n    const bad = URI.parse('file://' + '/coding/c#/project1');\r\n    bad.scheme === 'file';\r\n    bad.path === '/coding/c'; // path is now broken\r\n    bad.fragment === '/project1';\r\n    ```\r\n     *\r\n     * @param path A file system path (see `URI#fsPath`)\r\n     */\r\n    URI.file = function (path) {\r\n        var authority = _empty;\r\n        // normalize to fwd-slashes on windows,\r\n        // on other systems bwd-slashes are valid\r\n        // filename character, eg /f\\oo/ba\\r.txt\r\n        if (isWindows) {\r\n            path = path.replace(/\\\\/g, _slash);\r\n        }\r\n        // check for authority as used in UNC shares\r\n        // or use the path as given\r\n        if (path[0] === _slash && path[1] === _slash) {\r\n            var idx = path.indexOf(_slash, 2);\r\n            if (idx === -1) {\r\n                authority = path.substring(2);\r\n                path = _slash;\r\n            }\r\n            else {\r\n                authority = path.substring(2, idx);\r\n                path = path.substring(idx) || _slash;\r\n            }\r\n        }\r\n        return new _URI('file', authority, path, _empty, _empty);\r\n    };\r\n    URI.from = function (components) {\r\n        return new _URI(components.scheme, components.authority, components.path, components.query, components.fragment);\r\n    };\r\n    // ---- printing/externalize ---------------------------\r\n    /**\r\n     * Creates a string representation for this URI. It's guaranteed that calling\r\n     * `URI.parse` with the result of this function creates an URI which is equal\r\n     * to this URI.\r\n     *\r\n     * * The result shall *not* be used for display purposes but for externalization or transport.\r\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\r\n     * ignore the scheme-specific encoding rules.\r\n     *\r\n     * @param skipEncoding Do not encode the result, default is `false`\r\n     */\r\n    URI.prototype.toString = function (skipEncoding) {\r\n        if (skipEncoding === void 0) { skipEncoding = false; }\r\n        return _asFormatted(this, skipEncoding);\r\n    };\r\n    URI.prototype.toJSON = function () {\r\n        return this;\r\n    };\r\n    URI.revive = function (data) {\r\n        if (!data) {\r\n            return data;\r\n        }\r\n        else if (data instanceof URI) {\r\n            return data;\r\n        }\r\n        else {\r\n            var result = new _URI(data);\r\n            result._formatted = data.external;\r\n            result._fsPath = data._sep === _pathSepMarker ? data.fsPath : null;\r\n            return result;\r\n        }\r\n    };\r\n    return URI;\r\n}());\r\nexport { URI };\r\nvar _pathSepMarker = isWindows ? 1 : undefined;\r\n// eslint-disable-next-line @typescript-eslint/class-name-casing\r\nvar _URI = /** @class */ (function (_super) {\r\n    __extends(_URI, _super);\r\n    function _URI() {\r\n        var _this = _super !== null && _super.apply(this, arguments) || this;\r\n        _this._formatted = null;\r\n        _this._fsPath = null;\r\n        return _this;\r\n    }\r\n    Object.defineProperty(_URI.prototype, \"fsPath\", {\r\n        get: function () {\r\n            if (!this._fsPath) {\r\n                this._fsPath = _makeFsPath(this);\r\n            }\r\n            return this._fsPath;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    _URI.prototype.toString = function (skipEncoding) {\r\n        if (skipEncoding === void 0) { skipEncoding = false; }\r\n        if (!skipEncoding) {\r\n            if (!this._formatted) {\r\n                this._formatted = _asFormatted(this, false);\r\n            }\r\n            return this._formatted;\r\n        }\r\n        else {\r\n            // we don't cache that\r\n            return _asFormatted(this, true);\r\n        }\r\n    };\r\n    _URI.prototype.toJSON = function () {\r\n        var res = {\r\n            $mid: 1\r\n        };\r\n        // cached state\r\n        if (this._fsPath) {\r\n            res.fsPath = this._fsPath;\r\n            res._sep = _pathSepMarker;\r\n        }\r\n        if (this._formatted) {\r\n            res.external = this._formatted;\r\n        }\r\n        // uri components\r\n        if (this.path) {\r\n            res.path = this.path;\r\n        }\r\n        if (this.scheme) {\r\n            res.scheme = this.scheme;\r\n        }\r\n        if (this.authority) {\r\n            res.authority = this.authority;\r\n        }\r\n        if (this.query) {\r\n            res.query = this.query;\r\n        }\r\n        if (this.fragment) {\r\n            res.fragment = this.fragment;\r\n        }\r\n        return res;\r\n    };\r\n    return _URI;\r\n}(URI));\r\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\r\nvar encodeTable = (_a = {},\r\n    _a[58 /* Colon */] = '%3A',\r\n    _a[47 /* Slash */] = '%2F',\r\n    _a[63 /* QuestionMark */] = '%3F',\r\n    _a[35 /* Hash */] = '%23',\r\n    _a[91 /* OpenSquareBracket */] = '%5B',\r\n    _a[93 /* CloseSquareBracket */] = '%5D',\r\n    _a[64 /* AtSign */] = '%40',\r\n    _a[33 /* ExclamationMark */] = '%21',\r\n    _a[36 /* DollarSign */] = '%24',\r\n    _a[38 /* Ampersand */] = '%26',\r\n    _a[39 /* SingleQuote */] = '%27',\r\n    _a[40 /* OpenParen */] = '%28',\r\n    _a[41 /* CloseParen */] = '%29',\r\n    _a[42 /* Asterisk */] = '%2A',\r\n    _a[43 /* Plus */] = '%2B',\r\n    _a[44 /* Comma */] = '%2C',\r\n    _a[59 /* Semicolon */] = '%3B',\r\n    _a[61 /* Equals */] = '%3D',\r\n    _a[32 /* Space */] = '%20',\r\n    _a);\r\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\r\n    var res = undefined;\r\n    var nativeEncodePos = -1;\r\n    for (var pos = 0; pos < uriComponent.length; pos++) {\r\n        var code = uriComponent.charCodeAt(pos);\r\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\r\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\r\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\r\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\r\n            || code === 45 /* Dash */\r\n            || code === 46 /* Period */\r\n            || code === 95 /* Underline */\r\n            || code === 126 /* Tilde */\r\n            || (allowSlash && code === 47 /* Slash */)) {\r\n            // check if we are delaying native encode\r\n            if (nativeEncodePos !== -1) {\r\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\r\n                nativeEncodePos = -1;\r\n            }\r\n            // check if we write into a new string (by default we try to return the param)\r\n            if (res !== undefined) {\r\n                res += uriComponent.charAt(pos);\r\n            }\r\n        }\r\n        else {\r\n            // encoding needed, we need to allocate a new string\r\n            if (res === undefined) {\r\n                res = uriComponent.substr(0, pos);\r\n            }\r\n            // check with default table first\r\n            var escaped = encodeTable[code];\r\n            if (escaped !== undefined) {\r\n                // check if we are delaying native encode\r\n                if (nativeEncodePos !== -1) {\r\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\r\n                    nativeEncodePos = -1;\r\n                }\r\n                // append escaped variant to result\r\n                res += escaped;\r\n            }\r\n            else if (nativeEncodePos === -1) {\r\n                // use native encode only when needed\r\n                nativeEncodePos = pos;\r\n            }\r\n        }\r\n    }\r\n    if (nativeEncodePos !== -1) {\r\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\r\n    }\r\n    return res !== undefined ? res : uriComponent;\r\n}\r\nfunction encodeURIComponentMinimal(path) {\r\n    var res = undefined;\r\n    for (var pos = 0; pos < path.length; pos++) {\r\n        var code = path.charCodeAt(pos);\r\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\r\n            if (res === undefined) {\r\n                res = path.substr(0, pos);\r\n            }\r\n            res += encodeTable[code];\r\n        }\r\n        else {\r\n            if (res !== undefined) {\r\n                res += path[pos];\r\n            }\r\n        }\r\n    }\r\n    return res !== undefined ? res : path;\r\n}\r\n/**\r\n * Compute `fsPath` for the given uri\r\n */\r\nfunction _makeFsPath(uri) {\r\n    var value;\r\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\r\n        // unc path: file://shares/c$/far/boo\r\n        value = \"//\" + uri.authority + uri.path;\r\n    }\r\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\r\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 */)\r\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\r\n        // windows drive letter: file:///c:/far/boo\r\n        value = uri.path[1].toLowerCase() + uri.path.substr(2);\r\n    }\r\n    else {\r\n        // other path\r\n        value = uri.path;\r\n    }\r\n    if (isWindows) {\r\n        value = value.replace(/\\//g, '\\\\');\r\n    }\r\n    return value;\r\n}\r\n/**\r\n * Create the external version of a uri\r\n */\r\nfunction _asFormatted(uri, skipEncoding) {\r\n    var encoder = !skipEncoding\r\n        ? encodeURIComponentFast\r\n        : encodeURIComponentMinimal;\r\n    var res = '';\r\n    var scheme = uri.scheme, authority = uri.authority, path = uri.path, query = uri.query, fragment = uri.fragment;\r\n    if (scheme) {\r\n        res += scheme;\r\n        res += ':';\r\n    }\r\n    if (authority || scheme === 'file') {\r\n        res += _slash;\r\n        res += _slash;\r\n    }\r\n    if (authority) {\r\n        var idx = authority.indexOf('@');\r\n        if (idx !== -1) {\r\n            // <user>@<auth>\r\n            var userinfo = authority.substr(0, idx);\r\n            authority = authority.substr(idx + 1);\r\n            idx = userinfo.indexOf(':');\r\n            if (idx === -1) {\r\n                res += encoder(userinfo, false);\r\n            }\r\n            else {\r\n                // <user>:<pass>@<auth>\r\n                res += encoder(userinfo.substr(0, idx), false);\r\n                res += ':';\r\n                res += encoder(userinfo.substr(idx + 1), false);\r\n            }\r\n            res += '@';\r\n        }\r\n        authority = authority.toLowerCase();\r\n        idx = authority.indexOf(':');\r\n        if (idx === -1) {\r\n            res += encoder(authority, false);\r\n        }\r\n        else {\r\n            // <auth>:<port>\r\n            res += encoder(authority.substr(0, idx), false);\r\n            res += authority.substr(idx);\r\n        }\r\n    }\r\n    if (path) {\r\n        // lower-case windows drive letters in /C:/fff or C:/fff\r\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\r\n            var code = path.charCodeAt(1);\r\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\r\n                path = \"/\" + String.fromCharCode(code + 32) + \":\" + path.substr(3); // \"/c:\".length === 3\r\n            }\r\n        }\r\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\r\n            var code = path.charCodeAt(0);\r\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\r\n                path = String.fromCharCode(code + 32) + \":\" + path.substr(2); // \"/c:\".length === 3\r\n            }\r\n        }\r\n        // encode the rest of the path\r\n        res += encoder(path, true);\r\n    }\r\n    if (query) {\r\n        res += '?';\r\n        res += encoder(query, false);\r\n    }\r\n    if (fragment) {\r\n        res += '#';\r\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\r\n    }\r\n    return res;\r\n}\r\n// --- decode\r\nfunction decodeURIComponentGraceful(str) {\r\n    try {\r\n        return decodeURIComponent(str);\r\n    }\r\n    catch (_a) {\r\n        if (str.length > 3) {\r\n            return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));\r\n        }\r\n        else {\r\n            return str;\r\n        }\r\n    }\r\n}\r\nvar _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;\r\nfunction percentDecode(str) {\r\n    if (!str.match(_rEncodedAsHex)) {\r\n        return str;\r\n    }\r\n    return str.replace(_rEncodedAsHex, function (match) { return decodeURIComponentGraceful(match); });\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\n/**\r\n * A position in the editor.\r\n */\r\nvar Position = /** @class */ (function () {\r\n    function Position(lineNumber, column) {\r\n        this.lineNumber = lineNumber;\r\n        this.column = column;\r\n    }\r\n    /**\r\n     * Create a new position from this position.\r\n     *\r\n     * @param newLineNumber new line number\r\n     * @param newColumn new column\r\n     */\r\n    Position.prototype.with = function (newLineNumber, newColumn) {\r\n        if (newLineNumber === void 0) { newLineNumber = this.lineNumber; }\r\n        if (newColumn === void 0) { newColumn = this.column; }\r\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\r\n            return this;\r\n        }\r\n        else {\r\n            return new Position(newLineNumber, newColumn);\r\n        }\r\n    };\r\n    /**\r\n     * Derive a new position from this position.\r\n     *\r\n     * @param deltaLineNumber line number delta\r\n     * @param deltaColumn column delta\r\n     */\r\n    Position.prototype.delta = function (deltaLineNumber, deltaColumn) {\r\n        if (deltaLineNumber === void 0) { deltaLineNumber = 0; }\r\n        if (deltaColumn === void 0) { deltaColumn = 0; }\r\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\r\n    };\r\n    /**\r\n     * Test if this position equals other position\r\n     */\r\n    Position.prototype.equals = function (other) {\r\n        return Position.equals(this, other);\r\n    };\r\n    /**\r\n     * Test if position `a` equals position `b`\r\n     */\r\n    Position.equals = function (a, b) {\r\n        if (!a && !b) {\r\n            return true;\r\n        }\r\n        return (!!a &&\r\n            !!b &&\r\n            a.lineNumber === b.lineNumber &&\r\n            a.column === b.column);\r\n    };\r\n    /**\r\n     * Test if this position is before other position.\r\n     * If the two positions are equal, the result will be false.\r\n     */\r\n    Position.prototype.isBefore = function (other) {\r\n        return Position.isBefore(this, other);\r\n    };\r\n    /**\r\n     * Test if position `a` is before position `b`.\r\n     * If the two positions are equal, the result will be false.\r\n     */\r\n    Position.isBefore = function (a, b) {\r\n        if (a.lineNumber < b.lineNumber) {\r\n            return true;\r\n        }\r\n        if (b.lineNumber < a.lineNumber) {\r\n            return false;\r\n        }\r\n        return a.column < b.column;\r\n    };\r\n    /**\r\n     * Test if this position is before other position.\r\n     * If the two positions are equal, the result will be true.\r\n     */\r\n    Position.prototype.isBeforeOrEqual = function (other) {\r\n        return Position.isBeforeOrEqual(this, other);\r\n    };\r\n    /**\r\n     * Test if position `a` is before position `b`.\r\n     * If the two positions are equal, the result will be true.\r\n     */\r\n    Position.isBeforeOrEqual = function (a, b) {\r\n        if (a.lineNumber < b.lineNumber) {\r\n            return true;\r\n        }\r\n        if (b.lineNumber < a.lineNumber) {\r\n            return false;\r\n        }\r\n        return a.column <= b.column;\r\n    };\r\n    /**\r\n     * A function that compares positions, useful for sorting\r\n     */\r\n    Position.compare = function (a, b) {\r\n        var aLineNumber = a.lineNumber | 0;\r\n        var bLineNumber = b.lineNumber | 0;\r\n        if (aLineNumber === bLineNumber) {\r\n            var aColumn = a.column | 0;\r\n            var bColumn = b.column | 0;\r\n            return aColumn - bColumn;\r\n        }\r\n        return aLineNumber - bLineNumber;\r\n    };\r\n    /**\r\n     * Clone this position.\r\n     */\r\n    Position.prototype.clone = function () {\r\n        return new Position(this.lineNumber, this.column);\r\n    };\r\n    /**\r\n     * Convert to a human-readable representation.\r\n     */\r\n    Position.prototype.toString = function () {\r\n        return '(' + this.lineNumber + ',' + this.column + ')';\r\n    };\r\n    // ---\r\n    /**\r\n     * Create a `Position` from an `IPosition`.\r\n     */\r\n    Position.lift = function (pos) {\r\n        return new Position(pos.lineNumber, pos.column);\r\n    };\r\n    /**\r\n     * Test if `obj` is an `IPosition`.\r\n     */\r\n    Position.isIPosition = function (obj) {\r\n        return (obj\r\n            && (typeof obj.lineNumber === 'number')\r\n            && (typeof obj.column === 'number'));\r\n    };\r\n    return Position;\r\n}());\r\nexport { Position };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { Position } from './position.js';\r\n/**\r\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\r\n */\r\nvar Range = /** @class */ (function () {\r\n    function Range(startLineNumber, startColumn, endLineNumber, endColumn) {\r\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\r\n            this.startLineNumber = endLineNumber;\r\n            this.startColumn = endColumn;\r\n            this.endLineNumber = startLineNumber;\r\n            this.endColumn = startColumn;\r\n        }\r\n        else {\r\n            this.startLineNumber = startLineNumber;\r\n            this.startColumn = startColumn;\r\n            this.endLineNumber = endLineNumber;\r\n            this.endColumn = endColumn;\r\n        }\r\n    }\r\n    /**\r\n     * Test if this range is empty.\r\n     */\r\n    Range.prototype.isEmpty = function () {\r\n        return Range.isEmpty(this);\r\n    };\r\n    /**\r\n     * Test if `range` is empty.\r\n     */\r\n    Range.isEmpty = function (range) {\r\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\r\n    };\r\n    /**\r\n     * Test if position is in this range. If the position is at the edges, will return true.\r\n     */\r\n    Range.prototype.containsPosition = function (position) {\r\n        return Range.containsPosition(this, position);\r\n    };\r\n    /**\r\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\r\n     */\r\n    Range.containsPosition = function (range, position) {\r\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\r\n            return false;\r\n        }\r\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\r\n            return false;\r\n        }\r\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\r\n            return false;\r\n        }\r\n        return true;\r\n    };\r\n    /**\r\n     * Test if range is in this range. If the range is equal to this range, will return true.\r\n     */\r\n    Range.prototype.containsRange = function (range) {\r\n        return Range.containsRange(this, range);\r\n    };\r\n    /**\r\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\r\n     */\r\n    Range.containsRange = function (range, otherRange) {\r\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\r\n            return false;\r\n        }\r\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\r\n            return false;\r\n        }\r\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\r\n            return false;\r\n        }\r\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\r\n            return false;\r\n        }\r\n        return true;\r\n    };\r\n    /**\r\n     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.\r\n     */\r\n    Range.prototype.strictContainsRange = function (range) {\r\n        return Range.strictContainsRange(this, range);\r\n    };\r\n    /**\r\n     * Test if `otherRange` is strinctly in `range` (must start after, and end before). If the ranges are equal, will return false.\r\n     */\r\n    Range.strictContainsRange = function (range, otherRange) {\r\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\r\n            return false;\r\n        }\r\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\r\n            return false;\r\n        }\r\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {\r\n            return false;\r\n        }\r\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {\r\n            return false;\r\n        }\r\n        return true;\r\n    };\r\n    /**\r\n     * A reunion of the two ranges.\r\n     * The smallest position will be used as the start point, and the largest one as the end point.\r\n     */\r\n    Range.prototype.plusRange = function (range) {\r\n        return Range.plusRange(this, range);\r\n    };\r\n    /**\r\n     * A reunion of the two ranges.\r\n     * The smallest position will be used as the start point, and the largest one as the end point.\r\n     */\r\n    Range.plusRange = function (a, b) {\r\n        var startLineNumber;\r\n        var startColumn;\r\n        var endLineNumber;\r\n        var endColumn;\r\n        if (b.startLineNumber < a.startLineNumber) {\r\n            startLineNumber = b.startLineNumber;\r\n            startColumn = b.startColumn;\r\n        }\r\n        else if (b.startLineNumber === a.startLineNumber) {\r\n            startLineNumber = b.startLineNumber;\r\n            startColumn = Math.min(b.startColumn, a.startColumn);\r\n        }\r\n        else {\r\n            startLineNumber = a.startLineNumber;\r\n            startColumn = a.startColumn;\r\n        }\r\n        if (b.endLineNumber > a.endLineNumber) {\r\n            endLineNumber = b.endLineNumber;\r\n            endColumn = b.endColumn;\r\n        }\r\n        else if (b.endLineNumber === a.endLineNumber) {\r\n            endLineNumber = b.endLineNumber;\r\n            endColumn = Math.max(b.endColumn, a.endColumn);\r\n        }\r\n        else {\r\n            endLineNumber = a.endLineNumber;\r\n            endColumn = a.endColumn;\r\n        }\r\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\r\n    };\r\n    /**\r\n     * A intersection of the two ranges.\r\n     */\r\n    Range.prototype.intersectRanges = function (range) {\r\n        return Range.intersectRanges(this, range);\r\n    };\r\n    /**\r\n     * A intersection of the two ranges.\r\n     */\r\n    Range.intersectRanges = function (a, b) {\r\n        var resultStartLineNumber = a.startLineNumber;\r\n        var resultStartColumn = a.startColumn;\r\n        var resultEndLineNumber = a.endLineNumber;\r\n        var resultEndColumn = a.endColumn;\r\n        var otherStartLineNumber = b.startLineNumber;\r\n        var otherStartColumn = b.startColumn;\r\n        var otherEndLineNumber = b.endLineNumber;\r\n        var otherEndColumn = b.endColumn;\r\n        if (resultStartLineNumber < otherStartLineNumber) {\r\n            resultStartLineNumber = otherStartLineNumber;\r\n            resultStartColumn = otherStartColumn;\r\n        }\r\n        else if (resultStartLineNumber === otherStartLineNumber) {\r\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\r\n        }\r\n        if (resultEndLineNumber > otherEndLineNumber) {\r\n            resultEndLineNumber = otherEndLineNumber;\r\n            resultEndColumn = otherEndColumn;\r\n        }\r\n        else if (resultEndLineNumber === otherEndLineNumber) {\r\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\r\n        }\r\n        // Check if selection is now empty\r\n        if (resultStartLineNumber > resultEndLineNumber) {\r\n            return null;\r\n        }\r\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\r\n            return null;\r\n        }\r\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\r\n    };\r\n    /**\r\n     * Test if this range equals other.\r\n     */\r\n    Range.prototype.equalsRange = function (other) {\r\n        return Range.equalsRange(this, other);\r\n    };\r\n    /**\r\n     * Test if range `a` equals `b`.\r\n     */\r\n    Range.equalsRange = function (a, b) {\r\n        return (!!a &&\r\n            !!b &&\r\n            a.startLineNumber === b.startLineNumber &&\r\n            a.startColumn === b.startColumn &&\r\n            a.endLineNumber === b.endLineNumber &&\r\n            a.endColumn === b.endColumn);\r\n    };\r\n    /**\r\n     * Return the end position (which will be after or equal to the start position)\r\n     */\r\n    Range.prototype.getEndPosition = function () {\r\n        return new Position(this.endLineNumber, this.endColumn);\r\n    };\r\n    /**\r\n     * Return the start position (which will be before or equal to the end position)\r\n     */\r\n    Range.prototype.getStartPosition = function () {\r\n        return new Position(this.startLineNumber, this.startColumn);\r\n    };\r\n    /**\r\n     * Transform to a user presentable string representation.\r\n     */\r\n    Range.prototype.toString = function () {\r\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\r\n    };\r\n    /**\r\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\r\n     */\r\n    Range.prototype.setEndPosition = function (endLineNumber, endColumn) {\r\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\r\n    };\r\n    /**\r\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\r\n     */\r\n    Range.prototype.setStartPosition = function (startLineNumber, startColumn) {\r\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\r\n    };\r\n    /**\r\n     * Create a new empty range using this range's start position.\r\n     */\r\n    Range.prototype.collapseToStart = function () {\r\n        return Range.collapseToStart(this);\r\n    };\r\n    /**\r\n     * Create a new empty range using this range's start position.\r\n     */\r\n    Range.collapseToStart = function (range) {\r\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\r\n    };\r\n    // ---\r\n    Range.fromPositions = function (start, end) {\r\n        if (end === void 0) { end = start; }\r\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\r\n    };\r\n    Range.lift = function (range) {\r\n        if (!range) {\r\n            return null;\r\n        }\r\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\r\n    };\r\n    /**\r\n     * Test if `obj` is an `IRange`.\r\n     */\r\n    Range.isIRange = function (obj) {\r\n        return (obj\r\n            && (typeof obj.startLineNumber === 'number')\r\n            && (typeof obj.startColumn === 'number')\r\n            && (typeof obj.endLineNumber === 'number')\r\n            && (typeof obj.endColumn === 'number'));\r\n    };\r\n    /**\r\n     * Test if the two ranges are touching in any way.\r\n     */\r\n    Range.areIntersectingOrTouching = function (a, b) {\r\n        // Check if `a` is before `b`\r\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\r\n            return false;\r\n        }\r\n        // Check if `b` is before `a`\r\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\r\n            return false;\r\n        }\r\n        // These ranges must intersect\r\n        return true;\r\n    };\r\n    /**\r\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\r\n     */\r\n    Range.areIntersecting = function (a, b) {\r\n        // Check if `a` is before `b`\r\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\r\n            return false;\r\n        }\r\n        // Check if `b` is before `a`\r\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\r\n            return false;\r\n        }\r\n        // These ranges must intersect\r\n        return true;\r\n    };\r\n    /**\r\n     * A function that compares ranges, useful for sorting ranges\r\n     * It will first compare ranges on the startPosition and then on the endPosition\r\n     */\r\n    Range.compareRangesUsingStarts = function (a, b) {\r\n        if (a && b) {\r\n            var aStartLineNumber = a.startLineNumber | 0;\r\n            var bStartLineNumber = b.startLineNumber | 0;\r\n            if (aStartLineNumber === bStartLineNumber) {\r\n                var aStartColumn = a.startColumn | 0;\r\n                var bStartColumn = b.startColumn | 0;\r\n                if (aStartColumn === bStartColumn) {\r\n                    var aEndLineNumber = a.endLineNumber | 0;\r\n                    var bEndLineNumber = b.endLineNumber | 0;\r\n                    if (aEndLineNumber === bEndLineNumber) {\r\n                        var aEndColumn = a.endColumn | 0;\r\n                        var bEndColumn = b.endColumn | 0;\r\n                        return aEndColumn - bEndColumn;\r\n                    }\r\n                    return aEndLineNumber - bEndLineNumber;\r\n                }\r\n                return aStartColumn - bStartColumn;\r\n            }\r\n            return aStartLineNumber - bStartLineNumber;\r\n        }\r\n        var aExists = (a ? 1 : 0);\r\n        var bExists = (b ? 1 : 0);\r\n        return aExists - bExists;\r\n    };\r\n    /**\r\n     * A function that compares ranges, useful for sorting ranges\r\n     * It will first compare ranges on the endPosition and then on the startPosition\r\n     */\r\n    Range.compareRangesUsingEnds = function (a, b) {\r\n        if (a.endLineNumber === b.endLineNumber) {\r\n            if (a.endColumn === b.endColumn) {\r\n                if (a.startLineNumber === b.startLineNumber) {\r\n                    return a.startColumn - b.startColumn;\r\n                }\r\n                return a.startLineNumber - b.startLineNumber;\r\n            }\r\n            return a.endColumn - b.endColumn;\r\n        }\r\n        return a.endLineNumber - b.endLineNumber;\r\n    };\r\n    /**\r\n     * Test if the range spans multiple lines.\r\n     */\r\n    Range.spansMultipleLines = function (range) {\r\n        return range.endLineNumber > range.startLineNumber;\r\n    };\r\n    return Range;\r\n}());\r\nexport { Range };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nexport function isFalsyOrWhitespace(str) {\r\n    if (!str || typeof str !== 'string') {\r\n        return true;\r\n    }\r\n    return str.trim().length === 0;\r\n}\r\n/**\r\n * @returns the provided number with the given number of preceding zeros.\r\n */\r\nexport function pad(n, l, char) {\r\n    if (char === void 0) { char = '0'; }\r\n    var str = '' + n;\r\n    var r = [str];\r\n    for (var i = str.length; i < l; i++) {\r\n        r.push(char);\r\n    }\r\n    return r.reverse().join('');\r\n}\r\nvar _formatRegexp = /{(\\d+)}/g;\r\n/**\r\n * Helper to produce a string with a variable number of arguments. Insert variable segments\r\n * into the string using the {n} notation where N is the index of the argument following the string.\r\n * @param value string to which formatting is applied\r\n * @param args replacements for {n}-entries\r\n */\r\nexport function format(value) {\r\n    var args = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        args[_i - 1] = arguments[_i];\r\n    }\r\n    if (args.length === 0) {\r\n        return value;\r\n    }\r\n    return value.replace(_formatRegexp, function (match, group) {\r\n        var idx = parseInt(group, 10);\r\n        return isNaN(idx) || idx < 0 || idx >= args.length ?\r\n            match :\r\n            args[idx];\r\n    });\r\n}\r\n/**\r\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\r\n * being used e.g. in HTMLElement.innerHTML.\r\n */\r\nexport function escape(html) {\r\n    return html.replace(/[<>&]/g, function (match) {\r\n        switch (match) {\r\n            case '<': return '&lt;';\r\n            case '>': return '&gt;';\r\n            case '&': return '&amp;';\r\n            default: return match;\r\n        }\r\n    });\r\n}\r\n/**\r\n * Escapes regular expression characters in a given string\r\n */\r\nexport function escapeRegExpCharacters(value) {\r\n    return value.replace(/[\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)]/g, '\\\\$&');\r\n}\r\n/**\r\n * Removes all occurrences of needle from the beginning and end of haystack.\r\n * @param haystack string to trim\r\n * @param needle the thing to trim (default is a blank)\r\n */\r\nexport function trim(haystack, needle) {\r\n    if (needle === void 0) { needle = ' '; }\r\n    var trimmed = ltrim(haystack, needle);\r\n    return rtrim(trimmed, needle);\r\n}\r\n/**\r\n * Removes all occurrences of needle from the beginning of haystack.\r\n * @param haystack string to trim\r\n * @param needle the thing to trim\r\n */\r\nexport function ltrim(haystack, needle) {\r\n    if (!haystack || !needle) {\r\n        return haystack;\r\n    }\r\n    var needleLen = needle.length;\r\n    if (needleLen === 0 || haystack.length === 0) {\r\n        return haystack;\r\n    }\r\n    var offset = 0;\r\n    while (haystack.indexOf(needle, offset) === offset) {\r\n        offset = offset + needleLen;\r\n    }\r\n    return haystack.substring(offset);\r\n}\r\n/**\r\n * Removes all occurrences of needle from the end of haystack.\r\n * @param haystack string to trim\r\n * @param needle the thing to trim\r\n */\r\nexport function rtrim(haystack, needle) {\r\n    if (!haystack || !needle) {\r\n        return haystack;\r\n    }\r\n    var needleLen = needle.length, haystackLen = haystack.length;\r\n    if (needleLen === 0 || haystackLen === 0) {\r\n        return haystack;\r\n    }\r\n    var offset = haystackLen, idx = -1;\r\n    while (true) {\r\n        idx = haystack.lastIndexOf(needle, offset - 1);\r\n        if (idx === -1 || idx + needleLen !== offset) {\r\n            break;\r\n        }\r\n        if (idx === 0) {\r\n            return '';\r\n        }\r\n        offset = idx;\r\n    }\r\n    return haystack.substring(0, offset);\r\n}\r\nexport function convertSimple2RegExpPattern(pattern) {\r\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\r\n}\r\n/**\r\n * Determines if haystack starts with needle.\r\n */\r\nexport function startsWith(haystack, needle) {\r\n    if (haystack.length < needle.length) {\r\n        return false;\r\n    }\r\n    if (haystack === needle) {\r\n        return true;\r\n    }\r\n    for (var i = 0; i < needle.length; i++) {\r\n        if (haystack[i] !== needle[i]) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n/**\r\n * Determines if haystack ends with needle.\r\n */\r\nexport function endsWith(haystack, needle) {\r\n    var diff = haystack.length - needle.length;\r\n    if (diff > 0) {\r\n        return haystack.indexOf(needle, diff) === diff;\r\n    }\r\n    else if (diff === 0) {\r\n        return haystack === needle;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\nexport function createRegExp(searchString, isRegex, options) {\r\n    if (options === void 0) { options = {}; }\r\n    if (!searchString) {\r\n        throw new Error('Cannot create regex from empty string');\r\n    }\r\n    if (!isRegex) {\r\n        searchString = escapeRegExpCharacters(searchString);\r\n    }\r\n    if (options.wholeWord) {\r\n        if (!/\\B/.test(searchString.charAt(0))) {\r\n            searchString = '\\\\b' + searchString;\r\n        }\r\n        if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\r\n            searchString = searchString + '\\\\b';\r\n        }\r\n    }\r\n    var modifiers = '';\r\n    if (options.global) {\r\n        modifiers += 'g';\r\n    }\r\n    if (!options.matchCase) {\r\n        modifiers += 'i';\r\n    }\r\n    if (options.multiline) {\r\n        modifiers += 'm';\r\n    }\r\n    if (options.unicode) {\r\n        modifiers += 'u';\r\n    }\r\n    return new RegExp(searchString, modifiers);\r\n}\r\nexport function regExpLeadsToEndlessLoop(regexp) {\r\n    // Exit early if it's one of these special cases which are meant to match\r\n    // against an empty string\r\n    if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\r\n        return false;\r\n    }\r\n    // We check against an empty string. If the regular expression doesn't advance\r\n    // (e.g. ends in an endless loop) it will match an empty string.\r\n    var match = regexp.exec('');\r\n    return !!(match && regexp.lastIndex === 0);\r\n}\r\nexport function regExpFlags(regexp) {\r\n    return (regexp.global ? 'g' : '')\r\n        + (regexp.ignoreCase ? 'i' : '')\r\n        + (regexp.multiline ? 'm' : '')\r\n        + (regexp.unicode ? 'u' : '');\r\n}\r\n/**\r\n * Returns first index of the string that is not whitespace.\r\n * If string is empty or contains only whitespaces, returns -1\r\n */\r\nexport function firstNonWhitespaceIndex(str) {\r\n    for (var i = 0, len = str.length; i < len; i++) {\r\n        var chCode = str.charCodeAt(i);\r\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\r\n            return i;\r\n        }\r\n    }\r\n    return -1;\r\n}\r\n/**\r\n * Returns the leading whitespace of the string.\r\n * If the string contains only whitespaces, returns entire string\r\n */\r\nexport function getLeadingWhitespace(str, start, end) {\r\n    if (start === void 0) { start = 0; }\r\n    if (end === void 0) { end = str.length; }\r\n    for (var i = start; i < end; i++) {\r\n        var chCode = str.charCodeAt(i);\r\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\r\n            return str.substring(start, i);\r\n        }\r\n    }\r\n    return str.substring(start, end);\r\n}\r\n/**\r\n * Returns last index of the string that is not whitespace.\r\n * If string is empty or contains only whitespaces, returns -1\r\n */\r\nexport function lastNonWhitespaceIndex(str, startIndex) {\r\n    if (startIndex === void 0) { startIndex = str.length - 1; }\r\n    for (var i = startIndex; i >= 0; i--) {\r\n        var chCode = str.charCodeAt(i);\r\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\r\n            return i;\r\n        }\r\n    }\r\n    return -1;\r\n}\r\nexport function compare(a, b) {\r\n    if (a < b) {\r\n        return -1;\r\n    }\r\n    else if (a > b) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return 0;\r\n    }\r\n}\r\nexport function compareIgnoreCase(a, b) {\r\n    var len = Math.min(a.length, b.length);\r\n    for (var i = 0; i < len; i++) {\r\n        var codeA = a.charCodeAt(i);\r\n        var codeB = b.charCodeAt(i);\r\n        if (codeA === codeB) {\r\n            // equal\r\n            continue;\r\n        }\r\n        if (isUpperAsciiLetter(codeA)) {\r\n            codeA += 32;\r\n        }\r\n        if (isUpperAsciiLetter(codeB)) {\r\n            codeB += 32;\r\n        }\r\n        var diff = codeA - codeB;\r\n        if (diff === 0) {\r\n            // equal -> ignoreCase\r\n            continue;\r\n        }\r\n        else if (isLowerAsciiLetter(codeA) && isLowerAsciiLetter(codeB)) {\r\n            //\r\n            return diff;\r\n        }\r\n        else {\r\n            return compare(a.toLowerCase(), b.toLowerCase());\r\n        }\r\n    }\r\n    if (a.length < b.length) {\r\n        return -1;\r\n    }\r\n    else if (a.length > b.length) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return 0;\r\n    }\r\n}\r\nexport function isLowerAsciiLetter(code) {\r\n    return code >= 97 /* a */ && code <= 122 /* z */;\r\n}\r\nexport function isUpperAsciiLetter(code) {\r\n    return code >= 65 /* A */ && code <= 90 /* Z */;\r\n}\r\nfunction isAsciiLetter(code) {\r\n    return isLowerAsciiLetter(code) || isUpperAsciiLetter(code);\r\n}\r\nexport function equalsIgnoreCase(a, b) {\r\n    return a.length === b.length && doEqualsIgnoreCase(a, b);\r\n}\r\nfunction doEqualsIgnoreCase(a, b, stopAt) {\r\n    if (stopAt === void 0) { stopAt = a.length; }\r\n    for (var i = 0; i < stopAt; i++) {\r\n        var codeA = a.charCodeAt(i);\r\n        var codeB = b.charCodeAt(i);\r\n        if (codeA === codeB) {\r\n            continue;\r\n        }\r\n        // a-z A-Z\r\n        if (isAsciiLetter(codeA) && isAsciiLetter(codeB)) {\r\n            var diff = Math.abs(codeA - codeB);\r\n            if (diff !== 0 && diff !== 32) {\r\n                return false;\r\n            }\r\n        }\r\n        // Any other charcode\r\n        else {\r\n            if (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    return true;\r\n}\r\nexport function startsWithIgnoreCase(str, candidate) {\r\n    var candidateLength = candidate.length;\r\n    if (candidate.length > str.length) {\r\n        return false;\r\n    }\r\n    return doEqualsIgnoreCase(str, candidate, candidateLength);\r\n}\r\n/**\r\n * @returns the length of the common prefix of the two strings.\r\n */\r\nexport function commonPrefixLength(a, b) {\r\n    var i, len = Math.min(a.length, b.length);\r\n    for (i = 0; i < len; i++) {\r\n        if (a.charCodeAt(i) !== b.charCodeAt(i)) {\r\n            return i;\r\n        }\r\n    }\r\n    return len;\r\n}\r\n/**\r\n * @returns the length of the common suffix of the two strings.\r\n */\r\nexport function commonSuffixLength(a, b) {\r\n    var i, len = Math.min(a.length, b.length);\r\n    var aLastIndex = a.length - 1;\r\n    var bLastIndex = b.length - 1;\r\n    for (i = 0; i < len; i++) {\r\n        if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\r\n            return i;\r\n        }\r\n    }\r\n    return len;\r\n}\r\n// --- unicode\r\n// http://en.wikipedia.org/wiki/Surrogate_pair\r\n// Returns the code point starting at a specified index in a string\r\n// Code points U+0000 to U+D7FF and U+E000 to U+FFFF are represented on a single character\r\n// Code points U+10000 to U+10FFFF are represented on two consecutive characters\r\n//export function getUnicodePoint(str:string, index:number, len:number):number {\r\n//\tconst chrCode = str.charCodeAt(index);\r\n//\tif (0xD800 <= chrCode && chrCode <= 0xDBFF && index + 1 < len) {\r\n//\t\tconst nextChrCode = str.charCodeAt(index + 1);\r\n//\t\tif (0xDC00 <= nextChrCode && nextChrCode <= 0xDFFF) {\r\n//\t\t\treturn (chrCode - 0xD800) << 10 + (nextChrCode - 0xDC00) + 0x10000;\r\n//\t\t}\r\n//\t}\r\n//\treturn chrCode;\r\n//}\r\nexport function isHighSurrogate(charCode) {\r\n    return (0xD800 <= charCode && charCode <= 0xDBFF);\r\n}\r\nexport function isLowSurrogate(charCode) {\r\n    return (0xDC00 <= charCode && charCode <= 0xDFFF);\r\n}\r\n/**\r\n * get the code point that begins at offset `offset`\r\n */\r\nexport function getNextCodePoint(str, len, offset) {\r\n    var charCode = str.charCodeAt(offset);\r\n    if (isHighSurrogate(charCode) && offset + 1 < len) {\r\n        var nextCharCode = str.charCodeAt(offset + 1);\r\n        if (isLowSurrogate(nextCharCode)) {\r\n            return ((charCode - 0xD800) << 10) + (nextCharCode - 0xDC00) + 0x10000;\r\n        }\r\n    }\r\n    return charCode;\r\n}\r\n/**\r\n * get the code point that ends right before offset `offset`\r\n */\r\nfunction getPrevCodePoint(str, offset) {\r\n    var charCode = str.charCodeAt(offset - 1);\r\n    if (isLowSurrogate(charCode) && offset > 1) {\r\n        var prevCharCode = str.charCodeAt(offset - 2);\r\n        if (isHighSurrogate(prevCharCode)) {\r\n            return ((prevCharCode - 0xD800) << 10) + (charCode - 0xDC00) + 0x10000;\r\n        }\r\n    }\r\n    return charCode;\r\n}\r\nexport function nextCharLength(str, offset) {\r\n    var graphemeBreakTree = GraphemeBreakTree.getInstance();\r\n    var initialOffset = offset;\r\n    var len = str.length;\r\n    var initialCodePoint = getNextCodePoint(str, len, offset);\r\n    offset += (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\r\n    var graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\r\n    while (offset < len) {\r\n        var nextCodePoint = getNextCodePoint(str, len, offset);\r\n        var nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(nextCodePoint);\r\n        if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {\r\n            break;\r\n        }\r\n        offset += (nextCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\r\n        graphemeBreakType = nextGraphemeBreakType;\r\n    }\r\n    return (offset - initialOffset);\r\n}\r\nexport function prevCharLength(str, offset) {\r\n    var graphemeBreakTree = GraphemeBreakTree.getInstance();\r\n    var initialOffset = offset;\r\n    var initialCodePoint = getPrevCodePoint(str, offset);\r\n    offset -= (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\r\n    var graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\r\n    while (offset > 0) {\r\n        var prevCodePoint = getPrevCodePoint(str, offset);\r\n        var prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(prevCodePoint);\r\n        if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {\r\n            break;\r\n        }\r\n        offset -= (prevCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\r\n        graphemeBreakType = prevGraphemeBreakType;\r\n    }\r\n    return (initialOffset - offset);\r\n}\r\n/**\r\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-rtl-test.js\r\n */\r\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])/;\r\n/**\r\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\r\n */\r\nexport function containsRTL(str) {\r\n    return CONTAINS_RTL.test(str);\r\n}\r\n/**\r\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-emoji-test.js\r\n */\r\nvar CONTAINS_EMOJI = /(?:[\\u231A\\u231B\\u23F0\\u23F3\\u2600-\\u27BF\\u2B50\\u2B55]|\\uD83C[\\uDDE6-\\uDDFF\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDE4F\\uDE80-\\uDEFC\\uDFE0-\\uDFEB]|\\uD83E[\\uDD00-\\uDDFF\\uDE70-\\uDE73\\uDE78-\\uDE82\\uDE90-\\uDE95])/;\r\nexport function containsEmoji(str) {\r\n    return CONTAINS_EMOJI.test(str);\r\n}\r\nvar IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\r\n/**\r\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\r\n */\r\nexport function isBasicASCII(str) {\r\n    return IS_BASIC_ASCII.test(str);\r\n}\r\nexport function containsFullWidthCharacter(str) {\r\n    for (var i = 0, len = str.length; i < len; i++) {\r\n        if (isFullWidthCharacter(str.charCodeAt(i))) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nexport function isFullWidthCharacter(charCode) {\r\n    // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\r\n    // http://jrgraphix.net/research/unicode_blocks.php\r\n    //          2E80 — 2EFF   CJK Radicals Supplement\r\n    //          2F00 — 2FDF   Kangxi Radicals\r\n    //          2FF0 — 2FFF   Ideographic Description Characters\r\n    //          3000 — 303F   CJK Symbols and Punctuation\r\n    //          3040 — 309F   Hiragana\r\n    //          30A0 — 30FF   Katakana\r\n    //          3100 — 312F   Bopomofo\r\n    //          3130 — 318F   Hangul Compatibility Jamo\r\n    //          3190 — 319F   Kanbun\r\n    //          31A0 — 31BF   Bopomofo Extended\r\n    //          31F0 — 31FF   Katakana Phonetic Extensions\r\n    //          3200 — 32FF   Enclosed CJK Letters and Months\r\n    //          3300 — 33FF   CJK Compatibility\r\n    //          3400 — 4DBF   CJK Unified Ideographs Extension A\r\n    //          4DC0 — 4DFF   Yijing Hexagram Symbols\r\n    //          4E00 — 9FFF   CJK Unified Ideographs\r\n    //          A000 — A48F   Yi Syllables\r\n    //          A490 — A4CF   Yi Radicals\r\n    //          AC00 — D7AF   Hangul Syllables\r\n    // [IGNORE] D800 — DB7F   High Surrogates\r\n    // [IGNORE] DB80 — DBFF   High Private Use Surrogates\r\n    // [IGNORE] DC00 — DFFF   Low Surrogates\r\n    // [IGNORE] E000 — F8FF   Private Use Area\r\n    //          F900 — FAFF   CJK Compatibility Ideographs\r\n    // [IGNORE] FB00 — FB4F   Alphabetic Presentation Forms\r\n    // [IGNORE] FB50 — FDFF   Arabic Presentation Forms-A\r\n    // [IGNORE] FE00 — FE0F   Variation Selectors\r\n    // [IGNORE] FE20 — FE2F   Combining Half Marks\r\n    // [IGNORE] FE30 — FE4F   CJK Compatibility Forms\r\n    // [IGNORE] FE50 — FE6F   Small Form Variants\r\n    // [IGNORE] FE70 — FEFF   Arabic Presentation Forms-B\r\n    //          FF00 — FFEF   Halfwidth and Fullwidth Forms\r\n    //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\r\n    //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E\r\n    // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul\r\n    // [IGNORE] FFF0 — FFFF   Specials\r\n    charCode = +charCode; // @perf\r\n    return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\r\n        || (charCode >= 0xF900 && charCode <= 0xFAFF)\r\n        || (charCode >= 0xFF01 && charCode <= 0xFF5E));\r\n}\r\n/**\r\n * A fast function (therefore imprecise) to check if code points are emojis.\r\n * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-emoji-test.js\r\n */\r\nexport function isEmojiImprecise(x) {\r\n    return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x >= 9728 && x <= 10175) || (x >= 127744 && x <= 128591)\r\n        || (x >= 128640 && x <= 128764) || (x >= 128992 && x <= 129003) || (x >= 129280 && x <= 129535)\r\n        || (x >= 129648 && x <= 129651) || (x >= 129656 && x <= 129666) || (x >= 129680 && x <= 129685));\r\n}\r\n// -- UTF-8 BOM\r\nexport var UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);\r\nexport function startsWithUTF8BOM(str) {\r\n    return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);\r\n}\r\nexport function safeBtoa(str) {\r\n    return btoa(encodeURIComponent(str)); // we use encodeURIComponent because btoa fails for non Latin 1 values\r\n}\r\nexport function repeat(s, count) {\r\n    var result = '';\r\n    for (var i = 0; i < count; i++) {\r\n        result += s;\r\n    }\r\n    return result;\r\n}\r\nexport function containsUppercaseCharacter(target, ignoreEscapedChars) {\r\n    if (ignoreEscapedChars === void 0) { ignoreEscapedChars = false; }\r\n    if (!target) {\r\n        return false;\r\n    }\r\n    if (ignoreEscapedChars) {\r\n        target = target.replace(/\\\\./g, '');\r\n    }\r\n    return target.toLowerCase() !== target;\r\n}\r\n/**\r\n * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.\r\n */\r\nexport function singleLetterHash(n) {\r\n    var LETTERS_CNT = (90 /* Z */ - 65 /* A */ + 1);\r\n    n = n % (2 * LETTERS_CNT);\r\n    if (n < LETTERS_CNT) {\r\n        return String.fromCharCode(97 /* a */ + n);\r\n    }\r\n    return String.fromCharCode(65 /* A */ + n - LETTERS_CNT);\r\n}\r\n//#region Unicode Grapheme Break\r\nexport function getGraphemeBreakType(codePoint) {\r\n    var graphemeBreakTree = GraphemeBreakTree.getInstance();\r\n    return graphemeBreakTree.getGraphemeBreakType(codePoint);\r\n}\r\nexport function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {\r\n    // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules\r\n    // !!! Let's make the common case a bit faster\r\n    if (breakTypeA === 0 /* Other */) {\r\n        // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table\r\n        return (breakTypeB !== 5 /* Extend */ && breakTypeB !== 7 /* SpacingMark */);\r\n    }\r\n    // Do not break between a CR and LF. Otherwise, break before and after controls.\r\n    // GB3                                        CR × LF\r\n    // GB4                       (Control | CR | LF) ÷\r\n    // GB5                                           ÷ (Control | CR | LF)\r\n    if (breakTypeA === 2 /* CR */) {\r\n        if (breakTypeB === 3 /* LF */) {\r\n            return false; // GB3\r\n        }\r\n    }\r\n    if (breakTypeA === 4 /* Control */ || breakTypeA === 2 /* CR */ || breakTypeA === 3 /* LF */) {\r\n        return true; // GB4\r\n    }\r\n    if (breakTypeB === 4 /* Control */ || breakTypeB === 2 /* CR */ || breakTypeB === 3 /* LF */) {\r\n        return true; // GB5\r\n    }\r\n    // Do not break Hangul syllable sequences.\r\n    // GB6                                         L × (L | V | LV | LVT)\r\n    // GB7                                  (LV | V) × (V | T)\r\n    // GB8                                 (LVT | T) × T\r\n    if (breakTypeA === 8 /* L */) {\r\n        if (breakTypeB === 8 /* L */ || breakTypeB === 9 /* V */ || breakTypeB === 11 /* LV */ || breakTypeB === 12 /* LVT */) {\r\n            return false; // GB6\r\n        }\r\n    }\r\n    if (breakTypeA === 11 /* LV */ || breakTypeA === 9 /* V */) {\r\n        if (breakTypeB === 9 /* V */ || breakTypeB === 10 /* T */) {\r\n            return false; // GB7\r\n        }\r\n    }\r\n    if (breakTypeA === 12 /* LVT */ || breakTypeA === 10 /* T */) {\r\n        if (breakTypeB === 10 /* T */) {\r\n            return false; // GB8\r\n        }\r\n    }\r\n    // Do not break before extending characters or ZWJ.\r\n    // GB9                                           × (Extend | ZWJ)\r\n    if (breakTypeB === 5 /* Extend */ || breakTypeB === 13 /* ZWJ */) {\r\n        return false; // GB9\r\n    }\r\n    // The GB9a and GB9b rules only apply to extended grapheme clusters:\r\n    // Do not break before SpacingMarks, or after Prepend characters.\r\n    // GB9a                                          × SpacingMark\r\n    // GB9b                                  Prepend ×\r\n    if (breakTypeB === 7 /* SpacingMark */) {\r\n        return false; // GB9a\r\n    }\r\n    if (breakTypeA === 1 /* Prepend */) {\r\n        return false; // GB9b\r\n    }\r\n    // Do not break within emoji modifier sequences or emoji zwj sequences.\r\n    // GB11    \\p{Extended_Pictographic} Extend* ZWJ × \\p{Extended_Pictographic}\r\n    if (breakTypeA === 13 /* ZWJ */ && breakTypeB === 14 /* Extended_Pictographic */) {\r\n        // Note: we are not implementing the rule entirely here to avoid introducing states\r\n        return false; // GB11\r\n    }\r\n    // GB12                          sot (RI RI)* RI × RI\r\n    // GB13                        [^RI] (RI RI)* RI × RI\r\n    if (breakTypeA === 6 /* Regional_Indicator */ && breakTypeB === 6 /* Regional_Indicator */) {\r\n        // Note: we are not implementing the rule entirely here to avoid introducing states\r\n        return false; // GB12 & GB13\r\n    }\r\n    // GB999                                     Any ÷ Any\r\n    return true;\r\n}\r\nvar GraphemeBreakTree = /** @class */ (function () {\r\n    function GraphemeBreakTree() {\r\n        this._data = getGraphemeBreakRawData();\r\n    }\r\n    GraphemeBreakTree.getInstance = function () {\r\n        if (!GraphemeBreakTree._INSTANCE) {\r\n            GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();\r\n        }\r\n        return GraphemeBreakTree._INSTANCE;\r\n    };\r\n    GraphemeBreakTree.prototype.getGraphemeBreakType = function (codePoint) {\r\n        // !!! Let's make 7bit ASCII a bit faster: 0..31\r\n        if (codePoint < 32) {\r\n            if (codePoint === 10 /* LineFeed */) {\r\n                return 3 /* LF */;\r\n            }\r\n            if (codePoint === 13 /* CarriageReturn */) {\r\n                return 2 /* CR */;\r\n            }\r\n            return 4 /* Control */;\r\n        }\r\n        // !!! Let's make 7bit ASCII a bit faster: 32..126\r\n        if (codePoint < 127) {\r\n            return 0 /* Other */;\r\n        }\r\n        var data = this._data;\r\n        var nodeCount = data.length / 3;\r\n        var nodeIndex = 1;\r\n        while (nodeIndex <= nodeCount) {\r\n            if (codePoint < data[3 * nodeIndex]) {\r\n                // go left\r\n                nodeIndex = 2 * nodeIndex;\r\n            }\r\n            else if (codePoint > data[3 * nodeIndex + 1]) {\r\n                // go right\r\n                nodeIndex = 2 * nodeIndex + 1;\r\n            }\r\n            else {\r\n                // hit\r\n                return data[3 * nodeIndex + 2];\r\n            }\r\n        }\r\n        return 0 /* Other */;\r\n    };\r\n    GraphemeBreakTree._INSTANCE = null;\r\n    return GraphemeBreakTree;\r\n}());\r\nfunction getGraphemeBreakRawData() {\r\n    // generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-grapheme-break.js\r\n    return JSON.parse('[0,0,0,51592,51592,11,44424,44424,11,72251,72254,5,7150,7150,7,48008,48008,11,55176,55176,11,128420,128420,14,3276,3277,5,9979,9980,14,46216,46216,11,49800,49800,11,53384,53384,11,70726,70726,5,122915,122916,5,129320,129327,14,2558,2558,5,5906,5908,5,9762,9763,14,43360,43388,8,45320,45320,11,47112,47112,11,48904,48904,11,50696,50696,11,52488,52488,11,54280,54280,11,70082,70083,1,71350,71350,7,73111,73111,5,127892,127893,14,128726,128727,14,129473,129474,14,2027,2035,5,2901,2902,5,3784,3789,5,6754,6754,5,8418,8420,5,9877,9877,14,11088,11088,14,44008,44008,5,44872,44872,11,45768,45768,11,46664,46664,11,47560,47560,11,48456,48456,11,49352,49352,11,50248,50248,11,51144,51144,11,52040,52040,11,52936,52936,11,53832,53832,11,54728,54728,11,69811,69814,5,70459,70460,5,71096,71099,7,71998,71998,5,72874,72880,5,119149,119149,7,127374,127374,14,128335,128335,14,128482,128482,14,128765,128767,14,129399,129400,14,129680,129685,14,1476,1477,5,2377,2380,7,2759,2760,5,3137,3140,7,3458,3459,7,4153,4154,5,6432,6434,5,6978,6978,5,7675,7679,5,9723,9726,14,9823,9823,14,9919,9923,14,10035,10036,14,42736,42737,5,43596,43596,5,44200,44200,11,44648,44648,11,45096,45096,11,45544,45544,11,45992,45992,11,46440,46440,11,46888,46888,11,47336,47336,11,47784,47784,11,48232,48232,11,48680,48680,11,49128,49128,11,49576,49576,11,50024,50024,11,50472,50472,11,50920,50920,11,51368,51368,11,51816,51816,11,52264,52264,11,52712,52712,11,53160,53160,11,53608,53608,11,54056,54056,11,54504,54504,11,54952,54952,11,68108,68111,5,69933,69940,5,70197,70197,7,70498,70499,7,70845,70845,5,71229,71229,5,71727,71735,5,72154,72155,5,72344,72345,5,73023,73029,5,94095,94098,5,121403,121452,5,126981,127182,14,127538,127546,14,127990,127990,14,128391,128391,14,128445,128449,14,128500,128505,14,128752,128752,14,129160,129167,14,129356,129356,14,129432,129442,14,129648,129651,14,129751,131069,14,173,173,4,1757,1757,1,2274,2274,1,2494,2494,5,2641,2641,5,2876,2876,5,3014,3016,7,3262,3262,7,3393,3396,5,3570,3571,7,3968,3972,5,4228,4228,7,6086,6086,5,6679,6680,5,6912,6915,5,7080,7081,5,7380,7392,5,8252,8252,14,9096,9096,14,9748,9749,14,9784,9786,14,9833,9850,14,9890,9894,14,9938,9938,14,9999,9999,14,10085,10087,14,12349,12349,14,43136,43137,7,43454,43456,7,43755,43755,7,44088,44088,11,44312,44312,11,44536,44536,11,44760,44760,11,44984,44984,11,45208,45208,11,45432,45432,11,45656,45656,11,45880,45880,11,46104,46104,11,46328,46328,11,46552,46552,11,46776,46776,11,47000,47000,11,47224,47224,11,47448,47448,11,47672,47672,11,47896,47896,11,48120,48120,11,48344,48344,11,48568,48568,11,48792,48792,11,49016,49016,11,49240,49240,11,49464,49464,11,49688,49688,11,49912,49912,11,50136,50136,11,50360,50360,11,50584,50584,11,50808,50808,11,51032,51032,11,51256,51256,11,51480,51480,11,51704,51704,11,51928,51928,11,52152,52152,11,52376,52376,11,52600,52600,11,52824,52824,11,53048,53048,11,53272,53272,11,53496,53496,11,53720,53720,11,53944,53944,11,54168,54168,11,54392,54392,11,54616,54616,11,54840,54840,11,55064,55064,11,65438,65439,5,69633,69633,5,69837,69837,1,70018,70018,7,70188,70190,7,70368,70370,7,70465,70468,7,70712,70719,5,70835,70840,5,70850,70851,5,71132,71133,5,71340,71340,7,71458,71461,5,71985,71989,7,72002,72002,7,72193,72202,5,72281,72283,5,72766,72766,7,72885,72886,5,73104,73105,5,92912,92916,5,113824,113827,4,119173,119179,5,121505,121519,5,125136,125142,5,127279,127279,14,127489,127490,14,127570,127743,14,127900,127901,14,128254,128254,14,128369,128370,14,128400,128400,14,128425,128432,14,128468,128475,14,128489,128494,14,128715,128720,14,128745,128745,14,128759,128760,14,129004,129023,14,129296,129304,14,129340,129342,14,129388,129392,14,129404,129407,14,129454,129455,14,129485,129487,14,129659,129663,14,129719,129727,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2363,2363,7,2402,2403,5,2507,2508,7,2622,2624,7,2691,2691,7,2786,2787,5,2881,2884,5,3006,3006,5,3072,3072,5,3170,3171,5,3267,3268,7,3330,3331,7,3406,3406,1,3538,3540,5,3655,3662,5,3897,3897,5,4038,4038,5,4184,4185,5,4352,4447,8,6068,6069,5,6155,6157,5,6448,6449,7,6742,6742,5,6783,6783,5,6966,6970,5,7042,7042,7,7143,7143,7,7212,7219,5,7412,7412,5,8206,8207,4,8294,8303,4,8596,8601,14,9410,9410,14,9742,9742,14,9757,9757,14,9770,9770,14,9794,9794,14,9828,9828,14,9855,9855,14,9882,9882,14,9900,9903,14,9929,9933,14,9963,9967,14,9987,9988,14,10006,10006,14,10062,10062,14,10175,10175,14,11744,11775,5,42607,42607,5,43043,43044,7,43263,43263,5,43444,43445,7,43569,43570,5,43698,43700,5,43766,43766,5,44032,44032,11,44144,44144,11,44256,44256,11,44368,44368,11,44480,44480,11,44592,44592,11,44704,44704,11,44816,44816,11,44928,44928,11,45040,45040,11,45152,45152,11,45264,45264,11,45376,45376,11,45488,45488,11,45600,45600,11,45712,45712,11,45824,45824,11,45936,45936,11,46048,46048,11,46160,46160,11,46272,46272,11,46384,46384,11,46496,46496,11,46608,46608,11,46720,46720,11,46832,46832,11,46944,46944,11,47056,47056,11,47168,47168,11,47280,47280,11,47392,47392,11,47504,47504,11,47616,47616,11,47728,47728,11,47840,47840,11,47952,47952,11,48064,48064,11,48176,48176,11,48288,48288,11,48400,48400,11,48512,48512,11,48624,48624,11,48736,48736,11,48848,48848,11,48960,48960,11,49072,49072,11,49184,49184,11,49296,49296,11,49408,49408,11,49520,49520,11,49632,49632,11,49744,49744,11,49856,49856,11,49968,49968,11,50080,50080,11,50192,50192,11,50304,50304,11,50416,50416,11,50528,50528,11,50640,50640,11,50752,50752,11,50864,50864,11,50976,50976,11,51088,51088,11,51200,51200,11,51312,51312,11,51424,51424,11,51536,51536,11,51648,51648,11,51760,51760,11,51872,51872,11,51984,51984,11,52096,52096,11,52208,52208,11,52320,52320,11,52432,52432,11,52544,52544,11,52656,52656,11,52768,52768,11,52880,52880,11,52992,52992,11,53104,53104,11,53216,53216,11,53328,53328,11,53440,53440,11,53552,53552,11,53664,53664,11,53776,53776,11,53888,53888,11,54000,54000,11,54112,54112,11,54224,54224,11,54336,54336,11,54448,54448,11,54560,54560,11,54672,54672,11,54784,54784,11,54896,54896,11,55008,55008,11,55120,55120,11,64286,64286,5,66272,66272,5,68900,68903,5,69762,69762,7,69817,69818,5,69927,69931,5,70003,70003,5,70070,70078,5,70094,70094,7,70194,70195,7,70206,70206,5,70400,70401,5,70463,70463,7,70475,70477,7,70512,70516,5,70722,70724,5,70832,70832,5,70842,70842,5,70847,70848,5,71088,71089,7,71102,71102,7,71219,71226,5,71231,71232,5,71342,71343,7,71453,71455,5,71463,71467,5,71737,71738,5,71995,71996,5,72000,72000,7,72145,72147,7,72160,72160,5,72249,72249,7,72273,72278,5,72330,72342,5,72752,72758,5,72850,72871,5,72882,72883,5,73018,73018,5,73031,73031,5,73109,73109,5,73461,73462,7,94031,94031,5,94192,94193,7,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,126976,126979,14,127184,127231,14,127344,127345,14,127405,127461,14,127514,127514,14,127561,127567,14,127778,127779,14,127896,127896,14,127985,127986,14,127995,127999,5,128326,128328,14,128360,128366,14,128378,128378,14,128394,128397,14,128405,128406,14,128422,128423,14,128435,128443,14,128453,128464,14,128479,128480,14,128484,128487,14,128496,128498,14,128640,128709,14,128723,128724,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129096,129103,14,129292,129292,14,129311,129311,14,129329,129330,14,129344,129349,14,129360,129374,14,129394,129394,14,129402,129402,14,129413,129425,14,129445,129450,14,129466,129471,14,129483,129483,14,129511,129535,14,129653,129655,14,129667,129670,14,129705,129711,14,129731,129743,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2307,2307,7,2366,2368,7,2382,2383,7,2434,2435,7,2497,2500,5,2519,2519,5,2563,2563,7,2631,2632,5,2677,2677,5,2750,2752,7,2763,2764,7,2817,2817,5,2879,2879,5,2891,2892,7,2914,2915,5,3008,3008,5,3021,3021,5,3076,3076,5,3146,3149,5,3202,3203,7,3264,3265,7,3271,3272,7,3298,3299,5,3390,3390,5,3402,3404,7,3426,3427,5,3535,3535,5,3544,3550,7,3635,3635,7,3763,3763,7,3893,3893,5,3953,3966,5,3981,3991,5,4145,4145,7,4157,4158,5,4209,4212,5,4237,4237,5,4520,4607,10,5970,5971,5,6071,6077,5,6089,6099,5,6277,6278,5,6439,6440,5,6451,6456,7,6683,6683,5,6744,6750,5,6765,6770,7,6846,6846,5,6964,6964,5,6972,6972,5,7019,7027,5,7074,7077,5,7083,7085,5,7146,7148,7,7154,7155,7,7222,7223,5,7394,7400,5,7416,7417,5,8204,8204,5,8233,8233,4,8288,8292,4,8413,8416,5,8482,8482,14,8986,8987,14,9193,9203,14,9654,9654,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9775,14,9792,9792,14,9800,9811,14,9825,9826,14,9831,9831,14,9852,9853,14,9872,9873,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9936,9936,14,9941,9960,14,9974,9974,14,9982,9985,14,9992,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10145,10145,14,11013,11015,14,11503,11505,5,12334,12335,5,12951,12951,14,42612,42621,5,43014,43014,5,43047,43047,7,43204,43205,5,43335,43345,5,43395,43395,7,43450,43451,7,43561,43566,5,43573,43574,5,43644,43644,5,43710,43711,5,43758,43759,7,44005,44005,5,44012,44012,7,44060,44060,11,44116,44116,11,44172,44172,11,44228,44228,11,44284,44284,11,44340,44340,11,44396,44396,11,44452,44452,11,44508,44508,11,44564,44564,11,44620,44620,11,44676,44676,11,44732,44732,11,44788,44788,11,44844,44844,11,44900,44900,11,44956,44956,11,45012,45012,11,45068,45068,11,45124,45124,11,45180,45180,11,45236,45236,11,45292,45292,11,45348,45348,11,45404,45404,11,45460,45460,11,45516,45516,11,45572,45572,11,45628,45628,11,45684,45684,11,45740,45740,11,45796,45796,11,45852,45852,11,45908,45908,11,45964,45964,11,46020,46020,11,46076,46076,11,46132,46132,11,46188,46188,11,46244,46244,11,46300,46300,11,46356,46356,11,46412,46412,11,46468,46468,11,46524,46524,11,46580,46580,11,46636,46636,11,46692,46692,11,46748,46748,11,46804,46804,11,46860,46860,11,46916,46916,11,46972,46972,11,47028,47028,11,47084,47084,11,47140,47140,11,47196,47196,11,47252,47252,11,47308,47308,11,47364,47364,11,47420,47420,11,47476,47476,11,47532,47532,11,47588,47588,11,47644,47644,11,47700,47700,11,47756,47756,11,47812,47812,11,47868,47868,11,47924,47924,11,47980,47980,11,48036,48036,11,48092,48092,11,48148,48148,11,48204,48204,11,48260,48260,11,48316,48316,11,48372,48372,11,48428,48428,11,48484,48484,11,48540,48540,11,48596,48596,11,48652,48652,11,48708,48708,11,48764,48764,11,48820,48820,11,48876,48876,11,48932,48932,11,48988,48988,11,49044,49044,11,49100,49100,11,49156,49156,11,49212,49212,11,49268,49268,11,49324,49324,11,49380,49380,11,49436,49436,11,49492,49492,11,49548,49548,11,49604,49604,11,49660,49660,11,49716,49716,11,49772,49772,11,49828,49828,11,49884,49884,11,49940,49940,11,49996,49996,11,50052,50052,11,50108,50108,11,50164,50164,11,50220,50220,11,50276,50276,11,50332,50332,11,50388,50388,11,50444,50444,11,50500,50500,11,50556,50556,11,50612,50612,11,50668,50668,11,50724,50724,11,50780,50780,11,50836,50836,11,50892,50892,11,50948,50948,11,51004,51004,11,51060,51060,11,51116,51116,11,51172,51172,11,51228,51228,11,51284,51284,11,51340,51340,11,51396,51396,11,51452,51452,11,51508,51508,11,51564,51564,11,51620,51620,11,51676,51676,11,51732,51732,11,51788,51788,11,51844,51844,11,51900,51900,11,51956,51956,11,52012,52012,11,52068,52068,11,52124,52124,11,52180,52180,11,52236,52236,11,52292,52292,11,52348,52348,11,52404,52404,11,52460,52460,11,52516,52516,11,52572,52572,11,52628,52628,11,52684,52684,11,52740,52740,11,52796,52796,11,52852,52852,11,52908,52908,11,52964,52964,11,53020,53020,11,53076,53076,11,53132,53132,11,53188,53188,11,53244,53244,11,53300,53300,11,53356,53356,11,53412,53412,11,53468,53468,11,53524,53524,11,53580,53580,11,53636,53636,11,53692,53692,11,53748,53748,11,53804,53804,11,53860,53860,11,53916,53916,11,53972,53972,11,54028,54028,11,54084,54084,11,54140,54140,11,54196,54196,11,54252,54252,11,54308,54308,11,54364,54364,11,54420,54420,11,54476,54476,11,54532,54532,11,54588,54588,11,54644,54644,11,54700,54700,11,54756,54756,11,54812,54812,11,54868,54868,11,54924,54924,11,54980,54980,11,55036,55036,11,55092,55092,11,55148,55148,11,55216,55238,9,65056,65071,5,65529,65531,4,68097,68099,5,68159,68159,5,69446,69456,5,69688,69702,5,69808,69810,7,69815,69816,7,69821,69821,1,69888,69890,5,69932,69932,7,69957,69958,7,70016,70017,5,70067,70069,7,70079,70080,7,70089,70092,5,70095,70095,5,70191,70193,5,70196,70196,5,70198,70199,5,70367,70367,5,70371,70378,5,70402,70403,7,70462,70462,5,70464,70464,5,70471,70472,7,70487,70487,5,70502,70508,5,70709,70711,7,70720,70721,7,70725,70725,7,70750,70750,5,70833,70834,7,70841,70841,7,70843,70844,7,70846,70846,7,70849,70849,7,71087,71087,5,71090,71093,5,71100,71101,5,71103,71104,5,71216,71218,7,71227,71228,7,71230,71230,7,71339,71339,5,71341,71341,5,71344,71349,5,71351,71351,5,71456,71457,7,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123628,123631,5,125252,125258,5,126980,126980,14,127183,127183,14,127245,127247,14,127340,127343,14,127358,127359,14,127377,127386,14,127462,127487,6,127491,127503,14,127535,127535,14,127548,127551,14,127568,127569,14,127744,127777,14,127780,127891,14,127894,127895,14,127897,127899,14,127902,127984,14,127987,127989,14,127991,127994,14,128000,128253,14,128255,128317,14,128329,128334,14,128336,128359,14,128367,128368,14,128371,128377,14,128379,128390,14,128392,128393,14,128398,128399,14,128401,128404,14,128407,128419,14,128421,128421,14,128424,128424,14,128433,128434,14,128444,128444,14,128450,128452,14,128465,128467,14,128476,128478,14,128481,128481,14,128483,128483,14,128488,128488,14,128495,128495,14,128499,128499,14,128506,128591,14,128710,128714,14,128721,128722,14,128725,128725,14,128728,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129664,129666,14,129671,129679,14,129686,129704,14,129712,129718,14,129728,129730,14,129744,129750,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2259,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3134,3136,5,3142,3144,5,3157,3158,5,3201,3201,5,3260,3260,5,3263,3263,5,3266,3266,5,3270,3270,5,3274,3275,7,3285,3286,5,3328,3329,5,3387,3388,5,3391,3392,7,3398,3400,7,3405,3405,5,3415,3415,5,3457,3457,5,3530,3530,5,3536,3537,7,3542,3542,5,3551,3551,5,3633,3633,5,3636,3642,5,3761,3761,5,3764,3772,5,3864,3865,5,3895,3895,5,3902,3903,7,3967,3967,7,3974,3975,5,3993,4028,5,4141,4144,5,4146,4151,5,4155,4156,7,4182,4183,7,4190,4192,5,4226,4226,5,4229,4230,5,4253,4253,5,4448,4519,9,4957,4959,5,5938,5940,5,6002,6003,5,6070,6070,7,6078,6085,7,6087,6088,7,6109,6109,5,6158,6158,4,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6848,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7673,5,8203,8203,4,8205,8205,13,8232,8232,4,8234,8238,4,8265,8265,14,8293,8293,4,8400,8412,5,8417,8417,5,8421,8432,5,8505,8505,14,8617,8618,14,9000,9000,14,9167,9167,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9776,9783,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9935,14,9937,9937,14,9939,9940,14,9961,9962,14,9968,9973,14,9975,9978,14,9981,9981,14,9986,9986,14,9989,9989,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10084,14,10133,10135,14,10160,10160,14,10548,10549,14,11035,11036,14,11093,11093,14,11647,11647,5,12330,12333,5,12336,12336,14,12441,12442,5,12953,12953,14,42608,42610,5,42654,42655,5,43010,43010,5,43019,43019,5,43045,43046,5,43052,43052,5,43188,43203,7,43232,43249,5,43302,43309,5,43346,43347,7,43392,43394,5,43443,43443,5,43446,43449,5,43452,43453,5,43493,43493,5,43567,43568,7,43571,43572,7,43587,43587,5,43597,43597,7,43696,43696,5,43703,43704,5,43713,43713,5,43756,43757,5,43765,43765,7,44003,44004,7,44006,44007,7,44009,44010,7,44013,44013,5,44033,44059,12,44061,44087,12,44089,44115,12,44117,44143,12,44145,44171,12,44173,44199,12,44201,44227,12,44229,44255,12,44257,44283,12,44285,44311,12,44313,44339,12,44341,44367,12,44369,44395,12,44397,44423,12,44425,44451,12,44453,44479,12,44481,44507,12,44509,44535,12,44537,44563,12,44565,44591,12,44593,44619,12,44621,44647,12,44649,44675,12,44677,44703,12,44705,44731,12,44733,44759,12,44761,44787,12,44789,44815,12,44817,44843,12,44845,44871,12,44873,44899,12,44901,44927,12,44929,44955,12,44957,44983,12,44985,45011,12,45013,45039,12,45041,45067,12,45069,45095,12,45097,45123,12,45125,45151,12,45153,45179,12,45181,45207,12,45209,45235,12,45237,45263,12,45265,45291,12,45293,45319,12,45321,45347,12,45349,45375,12,45377,45403,12,45405,45431,12,45433,45459,12,45461,45487,12,45489,45515,12,45517,45543,12,45545,45571,12,45573,45599,12,45601,45627,12,45629,45655,12,45657,45683,12,45685,45711,12,45713,45739,12,45741,45767,12,45769,45795,12,45797,45823,12,45825,45851,12,45853,45879,12,45881,45907,12,45909,45935,12,45937,45963,12,45965,45991,12,45993,46019,12,46021,46047,12,46049,46075,12,46077,46103,12,46105,46131,12,46133,46159,12,46161,46187,12,46189,46215,12,46217,46243,12,46245,46271,12,46273,46299,12,46301,46327,12,46329,46355,12,46357,46383,12,46385,46411,12,46413,46439,12,46441,46467,12,46469,46495,12,46497,46523,12,46525,46551,12,46553,46579,12,46581,46607,12,46609,46635,12,46637,46663,12,46665,46691,12,46693,46719,12,46721,46747,12,46749,46775,12,46777,46803,12,46805,46831,12,46833,46859,12,46861,46887,12,46889,46915,12,46917,46943,12,46945,46971,12,46973,46999,12,47001,47027,12,47029,47055,12,47057,47083,12,47085,47111,12,47113,47139,12,47141,47167,12,47169,47195,12,47197,47223,12,47225,47251,12,47253,47279,12,47281,47307,12,47309,47335,12,47337,47363,12,47365,47391,12,47393,47419,12,47421,47447,12,47449,47475,12,47477,47503,12,47505,47531,12,47533,47559,12,47561,47587,12,47589,47615,12,47617,47643,12,47645,47671,12,47673,47699,12,47701,47727,12,47729,47755,12,47757,47783,12,47785,47811,12,47813,47839,12,47841,47867,12,47869,47895,12,47897,47923,12,47925,47951,12,47953,47979,12,47981,48007,12,48009,48035,12,48037,48063,12,48065,48091,12,48093,48119,12,48121,48147,12,48149,48175,12,48177,48203,12,48205,48231,12,48233,48259,12,48261,48287,12,48289,48315,12,48317,48343,12,48345,48371,12,48373,48399,12,48401,48427,12,48429,48455,12,48457,48483,12,48485,48511,12,48513,48539,12,48541,48567,12,48569,48595,12,48597,48623,12,48625,48651,12,48653,48679,12,48681,48707,12,48709,48735,12,48737,48763,12,48765,48791,12,48793,48819,12,48821,48847,12,48849,48875,12,48877,48903,12,48905,48931,12,48933,48959,12,48961,48987,12,48989,49015,12,49017,49043,12,49045,49071,12,49073,49099,12,49101,49127,12,49129,49155,12,49157,49183,12,49185,49211,12,49213,49239,12,49241,49267,12,49269,49295,12,49297,49323,12,49325,49351,12,49353,49379,12,49381,49407,12,49409,49435,12,49437,49463,12,49465,49491,12,49493,49519,12,49521,49547,12,49549,49575,12,49577,49603,12,49605,49631,12,49633,49659,12,49661,49687,12,49689,49715,12,49717,49743,12,49745,49771,12,49773,49799,12,49801,49827,12,49829,49855,12,49857,49883,12,49885,49911,12,49913,49939,12,49941,49967,12,49969,49995,12,49997,50023,12,50025,50051,12,50053,50079,12,50081,50107,12,50109,50135,12,50137,50163,12,50165,50191,12,50193,50219,12,50221,50247,12,50249,50275,12,50277,50303,12,50305,50331,12,50333,50359,12,50361,50387,12,50389,50415,12,50417,50443,12,50445,50471,12,50473,50499,12,50501,50527,12,50529,50555,12,50557,50583,12,50585,50611,12,50613,50639,12,50641,50667,12,50669,50695,12,50697,50723,12,50725,50751,12,50753,50779,12,50781,50807,12,50809,50835,12,50837,50863,12,50865,50891,12,50893,50919,12,50921,50947,12,50949,50975,12,50977,51003,12,51005,51031,12,51033,51059,12,51061,51087,12,51089,51115,12,51117,51143,12,51145,51171,12,51173,51199,12,51201,51227,12,51229,51255,12,51257,51283,12,51285,51311,12,51313,51339,12,51341,51367,12,51369,51395,12,51397,51423,12,51425,51451,12,51453,51479,12,51481,51507,12,51509,51535,12,51537,51563,12,51565,51591,12,51593,51619,12,51621,51647,12,51649,51675,12,51677,51703,12,51705,51731,12,51733,51759,12,51761,51787,12,51789,51815,12,51817,51843,12,51845,51871,12,51873,51899,12,51901,51927,12,51929,51955,12,51957,51983,12,51985,52011,12,52013,52039,12,52041,52067,12,52069,52095,12,52097,52123,12,52125,52151,12,52153,52179,12,52181,52207,12,52209,52235,12,52237,52263,12,52265,52291,12,52293,52319,12,52321,52347,12,52349,52375,12,52377,52403,12,52405,52431,12,52433,52459,12,52461,52487,12,52489,52515,12,52517,52543,12,52545,52571,12,52573,52599,12,52601,52627,12,52629,52655,12,52657,52683,12,52685,52711,12,52713,52739,12,52741,52767,12,52769,52795,12,52797,52823,12,52825,52851,12,52853,52879,12,52881,52907,12,52909,52935,12,52937,52963,12,52965,52991,12,52993,53019,12,53021,53047,12,53049,53075,12,53077,53103,12,53105,53131,12,53133,53159,12,53161,53187,12,53189,53215,12,53217,53243,12,53245,53271,12,53273,53299,12,53301,53327,12,53329,53355,12,53357,53383,12,53385,53411,12,53413,53439,12,53441,53467,12,53469,53495,12,53497,53523,12,53525,53551,12,53553,53579,12,53581,53607,12,53609,53635,12,53637,53663,12,53665,53691,12,53693,53719,12,53721,53747,12,53749,53775,12,53777,53803,12,53805,53831,12,53833,53859,12,53861,53887,12,53889,53915,12,53917,53943,12,53945,53971,12,53973,53999,12,54001,54027,12,54029,54055,12,54057,54083,12,54085,54111,12,54113,54139,12,54141,54167,12,54169,54195,12,54197,54223,12,54225,54251,12,54253,54279,12,54281,54307,12,54309,54335,12,54337,54363,12,54365,54391,12,54393,54419,12,54421,54447,12,54449,54475,12,54477,54503,12,54505,54531,12,54533,54559,12,54561,54587,12,54589,54615,12,54617,54643,12,54645,54671,12,54673,54699,12,54701,54727,12,54729,54755,12,54757,54783,12,54785,54811,12,54813,54839,12,54841,54867,12,54869,54895,12,54897,54923,12,54925,54951,12,54953,54979,12,54981,55007,12,55009,55035,12,55037,55063,12,55065,55091,12,55093,55119,12,55121,55147,12,55149,55175,12,55177,55203,12,55243,55291,10,65024,65039,5,65279,65279,4,65520,65528,4,66045,66045,5,66422,66426,5,68101,68102,5,68152,68154,5,68325,68326,5,69291,69292,5,69632,69632,7,69634,69634,7,69759,69761,5]');\r\n}\r\n//#endregion\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { LcsDiff } from '../../../base/common/diff/diff.js';\r\nimport * as strings from '../../../base/common/strings.js';\r\nvar MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\r\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\r\n    var diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\r\n    return diffAlgo.ComputeDiff(pretty);\r\n}\r\nvar LineSequence = /** @class */ (function () {\r\n    function LineSequence(lines) {\r\n        var startColumns = [];\r\n        var endColumns = [];\r\n        for (var i = 0, length_1 = lines.length; i < length_1; i++) {\r\n            startColumns[i] = getFirstNonBlankColumn(lines[i], 1);\r\n            endColumns[i] = getLastNonBlankColumn(lines[i], 1);\r\n        }\r\n        this.lines = lines;\r\n        this._startColumns = startColumns;\r\n        this._endColumns = endColumns;\r\n    }\r\n    LineSequence.prototype.getElements = function () {\r\n        var elements = [];\r\n        for (var i = 0, len = this.lines.length; i < len; i++) {\r\n            elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\r\n        }\r\n        return elements;\r\n    };\r\n    LineSequence.prototype.getStartLineNumber = function (i) {\r\n        return i + 1;\r\n    };\r\n    LineSequence.prototype.getEndLineNumber = function (i) {\r\n        return i + 1;\r\n    };\r\n    LineSequence.prototype.createCharSequence = function (shouldIgnoreTrimWhitespace, startIndex, endIndex) {\r\n        var charCodes = [];\r\n        var lineNumbers = [];\r\n        var columns = [];\r\n        var len = 0;\r\n        for (var index = startIndex; index <= endIndex; index++) {\r\n            var lineContent = this.lines[index];\r\n            var startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\r\n            var endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\r\n            for (var col = startColumn; col < endColumn; col++) {\r\n                charCodes[len] = lineContent.charCodeAt(col - 1);\r\n                lineNumbers[len] = index + 1;\r\n                columns[len] = col;\r\n                len++;\r\n            }\r\n        }\r\n        return new CharSequence(charCodes, lineNumbers, columns);\r\n    };\r\n    return LineSequence;\r\n}());\r\nvar CharSequence = /** @class */ (function () {\r\n    function CharSequence(charCodes, lineNumbers, columns) {\r\n        this._charCodes = charCodes;\r\n        this._lineNumbers = lineNumbers;\r\n        this._columns = columns;\r\n    }\r\n    CharSequence.prototype.getElements = function () {\r\n        return this._charCodes;\r\n    };\r\n    CharSequence.prototype.getStartLineNumber = function (i) {\r\n        return this._lineNumbers[i];\r\n    };\r\n    CharSequence.prototype.getStartColumn = function (i) {\r\n        return this._columns[i];\r\n    };\r\n    CharSequence.prototype.getEndLineNumber = function (i) {\r\n        return this._lineNumbers[i];\r\n    };\r\n    CharSequence.prototype.getEndColumn = function (i) {\r\n        return this._columns[i] + 1;\r\n    };\r\n    return CharSequence;\r\n}());\r\nvar CharChange = /** @class */ (function () {\r\n    function CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\r\n        this.originalStartLineNumber = originalStartLineNumber;\r\n        this.originalStartColumn = originalStartColumn;\r\n        this.originalEndLineNumber = originalEndLineNumber;\r\n        this.originalEndColumn = originalEndColumn;\r\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\r\n        this.modifiedStartColumn = modifiedStartColumn;\r\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\r\n        this.modifiedEndColumn = modifiedEndColumn;\r\n    }\r\n    CharChange.createFromDiffChange = function (diffChange, originalCharSequence, modifiedCharSequence) {\r\n        var originalStartLineNumber;\r\n        var originalStartColumn;\r\n        var originalEndLineNumber;\r\n        var originalEndColumn;\r\n        var modifiedStartLineNumber;\r\n        var modifiedStartColumn;\r\n        var modifiedEndLineNumber;\r\n        var modifiedEndColumn;\r\n        if (diffChange.originalLength === 0) {\r\n            originalStartLineNumber = 0;\r\n            originalStartColumn = 0;\r\n            originalEndLineNumber = 0;\r\n            originalEndColumn = 0;\r\n        }\r\n        else {\r\n            originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\r\n            originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\r\n            originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\r\n            originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\r\n        }\r\n        if (diffChange.modifiedLength === 0) {\r\n            modifiedStartLineNumber = 0;\r\n            modifiedStartColumn = 0;\r\n            modifiedEndLineNumber = 0;\r\n            modifiedEndColumn = 0;\r\n        }\r\n        else {\r\n            modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\r\n            modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\r\n            modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\r\n            modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\r\n        }\r\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\r\n    };\r\n    return CharChange;\r\n}());\r\nfunction postProcessCharChanges(rawChanges) {\r\n    if (rawChanges.length <= 1) {\r\n        return rawChanges;\r\n    }\r\n    var result = [rawChanges[0]];\r\n    var prevChange = result[0];\r\n    for (var i = 1, len = rawChanges.length; i < len; i++) {\r\n        var currChange = rawChanges[i];\r\n        var originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\r\n        var modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\r\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\r\n        var matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\r\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\r\n            // Merge the current change into the previous one\r\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\r\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\r\n        }\r\n        else {\r\n            // Add the current change\r\n            result.push(currChange);\r\n            prevChange = currChange;\r\n        }\r\n    }\r\n    return result;\r\n}\r\nvar LineChange = /** @class */ (function () {\r\n    function LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\r\n        this.originalStartLineNumber = originalStartLineNumber;\r\n        this.originalEndLineNumber = originalEndLineNumber;\r\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\r\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\r\n        this.charChanges = charChanges;\r\n    }\r\n    LineChange.createFromDiffResult = function (shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {\r\n        var originalStartLineNumber;\r\n        var originalEndLineNumber;\r\n        var modifiedStartLineNumber;\r\n        var modifiedEndLineNumber;\r\n        var charChanges = undefined;\r\n        if (diffChange.originalLength === 0) {\r\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\r\n            originalEndLineNumber = 0;\r\n        }\r\n        else {\r\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\r\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\r\n        }\r\n        if (diffChange.modifiedLength === 0) {\r\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\r\n            modifiedEndLineNumber = 0;\r\n        }\r\n        else {\r\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\r\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\r\n        }\r\n        if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {\r\n            // Compute character changes for diff chunks of at most 20 lines...\r\n            var originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\r\n            var modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\r\n            var rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;\r\n            if (shouldPostProcessCharChanges) {\r\n                rawChanges = postProcessCharChanges(rawChanges);\r\n            }\r\n            charChanges = [];\r\n            for (var i = 0, length_2 = rawChanges.length; i < length_2; i++) {\r\n                charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\r\n            }\r\n        }\r\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\r\n    };\r\n    return LineChange;\r\n}());\r\nvar DiffComputer = /** @class */ (function () {\r\n    function DiffComputer(originalLines, modifiedLines, opts) {\r\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\r\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\r\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\r\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\r\n        this.originalLines = originalLines;\r\n        this.modifiedLines = modifiedLines;\r\n        this.original = new LineSequence(originalLines);\r\n        this.modified = new LineSequence(modifiedLines);\r\n        this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);\r\n        this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...\r\n    }\r\n    DiffComputer.prototype.computeDiff = function () {\r\n        if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {\r\n            // empty original => fast path\r\n            return {\r\n                quitEarly: false,\r\n                changes: [{\r\n                        originalStartLineNumber: 1,\r\n                        originalEndLineNumber: 1,\r\n                        modifiedStartLineNumber: 1,\r\n                        modifiedEndLineNumber: this.modified.lines.length,\r\n                        charChanges: [{\r\n                                modifiedEndColumn: 0,\r\n                                modifiedEndLineNumber: 0,\r\n                                modifiedStartColumn: 0,\r\n                                modifiedStartLineNumber: 0,\r\n                                originalEndColumn: 0,\r\n                                originalEndLineNumber: 0,\r\n                                originalStartColumn: 0,\r\n                                originalStartLineNumber: 0\r\n                            }]\r\n                    }]\r\n            };\r\n        }\r\n        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\r\n            // empty modified => fast path\r\n            return {\r\n                quitEarly: false,\r\n                changes: [{\r\n                        originalStartLineNumber: 1,\r\n                        originalEndLineNumber: this.original.lines.length,\r\n                        modifiedStartLineNumber: 1,\r\n                        modifiedEndLineNumber: 1,\r\n                        charChanges: [{\r\n                                modifiedEndColumn: 0,\r\n                                modifiedEndLineNumber: 0,\r\n                                modifiedStartColumn: 0,\r\n                                modifiedStartLineNumber: 0,\r\n                                originalEndColumn: 0,\r\n                                originalEndLineNumber: 0,\r\n                                originalStartColumn: 0,\r\n                                originalStartLineNumber: 0\r\n                            }]\r\n                    }]\r\n            };\r\n        }\r\n        var diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);\r\n        var rawChanges = diffResult.changes;\r\n        var quitEarly = diffResult.quitEarly;\r\n        // The diff is always computed with ignoring trim whitespace\r\n        // This ensures we get the prettiest diff\r\n        if (this.shouldIgnoreTrimWhitespace) {\r\n            var lineChanges = [];\r\n            for (var i = 0, length_3 = rawChanges.length; i < length_3; i++) {\r\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\r\n            }\r\n            return {\r\n                quitEarly: quitEarly,\r\n                changes: lineChanges\r\n            };\r\n        }\r\n        // Need to post-process and introduce changes where the trim whitespace is different\r\n        // Note that we are looping starting at -1 to also cover the lines before the first change\r\n        var result = [];\r\n        var originalLineIndex = 0;\r\n        var modifiedLineIndex = 0;\r\n        for (var i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\r\n            var nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\r\n            var originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\r\n            var modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\r\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\r\n                var originalLine = this.originalLines[originalLineIndex];\r\n                var modifiedLine = this.modifiedLines[modifiedLineIndex];\r\n                if (originalLine !== modifiedLine) {\r\n                    // These lines differ only in trim whitespace\r\n                    // Check the leading whitespace\r\n                    {\r\n                        var originalStartColumn = getFirstNonBlankColumn(originalLine, 1);\r\n                        var modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);\r\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\r\n                            var originalChar = originalLine.charCodeAt(originalStartColumn - 2);\r\n                            var modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\r\n                            if (originalChar !== modifiedChar) {\r\n                                break;\r\n                            }\r\n                            originalStartColumn--;\r\n                            modifiedStartColumn--;\r\n                        }\r\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\r\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\r\n                        }\r\n                    }\r\n                    // Check the trailing whitespace\r\n                    {\r\n                        var originalEndColumn = getLastNonBlankColumn(originalLine, 1);\r\n                        var modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);\r\n                        var originalMaxColumn = originalLine.length + 1;\r\n                        var modifiedMaxColumn = modifiedLine.length + 1;\r\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\r\n                            var originalChar = originalLine.charCodeAt(originalEndColumn - 1);\r\n                            var modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\r\n                            if (originalChar !== modifiedChar) {\r\n                                break;\r\n                            }\r\n                            originalEndColumn++;\r\n                            modifiedEndColumn++;\r\n                        }\r\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\r\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\r\n                        }\r\n                    }\r\n                }\r\n                originalLineIndex++;\r\n                modifiedLineIndex++;\r\n            }\r\n            if (nextChange) {\r\n                // Emit the actual change\r\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\r\n                originalLineIndex += nextChange.originalLength;\r\n                modifiedLineIndex += nextChange.modifiedLength;\r\n            }\r\n        }\r\n        return {\r\n            quitEarly: quitEarly,\r\n            changes: result\r\n        };\r\n    };\r\n    DiffComputer.prototype._pushTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\r\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\r\n            // Merged into previous\r\n            return;\r\n        }\r\n        var charChanges = undefined;\r\n        if (this.shouldComputeCharChanges) {\r\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\r\n        }\r\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\r\n    };\r\n    DiffComputer.prototype._mergeTrimWhitespaceCharChange = function (result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\r\n        var len = result.length;\r\n        if (len === 0) {\r\n            return false;\r\n        }\r\n        var prevChange = result[len - 1];\r\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\r\n            // Don't merge with inserts/deletes\r\n            return false;\r\n        }\r\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\r\n            prevChange.originalEndLineNumber = originalLineNumber;\r\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\r\n            if (this.shouldComputeCharChanges && prevChange.charChanges) {\r\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\r\n            }\r\n            return true;\r\n        }\r\n        return false;\r\n    };\r\n    return DiffComputer;\r\n}());\r\nexport { DiffComputer };\r\nfunction getFirstNonBlankColumn(txt, defaultValue) {\r\n    var r = strings.firstNonWhitespaceIndex(txt);\r\n    if (r === -1) {\r\n        return defaultValue;\r\n    }\r\n    return r + 1;\r\n}\r\nfunction getLastNonBlankColumn(txt, defaultValue) {\r\n    var r = strings.lastNonWhitespaceIndex(txt);\r\n    if (r === -1) {\r\n        return defaultValue;\r\n    }\r\n    return r + 2;\r\n}\r\nfunction createContinueProcessingPredicate(maximumRuntime) {\r\n    if (maximumRuntime === 0) {\r\n        return function () { return true; };\r\n    }\r\n    var startTime = Date.now();\r\n    return function () {\r\n        return Date.now() - startTime < maximumRuntime;\r\n    };\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nexport function toUint8(v) {\r\n    if (v < 0) {\r\n        return 0;\r\n    }\r\n    if (v > 255 /* MAX_UINT_8 */) {\r\n        return 255 /* MAX_UINT_8 */;\r\n    }\r\n    return v | 0;\r\n}\r\nexport function toUint32(v) {\r\n    if (v < 0) {\r\n        return 0;\r\n    }\r\n    if (v > 4294967295 /* MAX_UINT_32 */) {\r\n        return 4294967295 /* MAX_UINT_32 */;\r\n    }\r\n    return v | 0;\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { toUint32 } from '../../../base/common/uint.js';\r\nvar PrefixSumIndexOfResult = /** @class */ (function () {\r\n    function PrefixSumIndexOfResult(index, remainder) {\r\n        this.index = index;\r\n        this.remainder = remainder;\r\n    }\r\n    return PrefixSumIndexOfResult;\r\n}());\r\nexport { PrefixSumIndexOfResult };\r\nvar PrefixSumComputer = /** @class */ (function () {\r\n    function PrefixSumComputer(values) {\r\n        this.values = values;\r\n        this.prefixSum = new Uint32Array(values.length);\r\n        this.prefixSumValidIndex = new Int32Array(1);\r\n        this.prefixSumValidIndex[0] = -1;\r\n    }\r\n    PrefixSumComputer.prototype.insertValues = function (insertIndex, insertValues) {\r\n        insertIndex = toUint32(insertIndex);\r\n        var oldValues = this.values;\r\n        var oldPrefixSum = this.prefixSum;\r\n        var insertValuesLen = insertValues.length;\r\n        if (insertValuesLen === 0) {\r\n            return false;\r\n        }\r\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\r\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\r\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\r\n        this.values.set(insertValues, insertIndex);\r\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\r\n            this.prefixSumValidIndex[0] = insertIndex - 1;\r\n        }\r\n        this.prefixSum = new Uint32Array(this.values.length);\r\n        if (this.prefixSumValidIndex[0] >= 0) {\r\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\r\n        }\r\n        return true;\r\n    };\r\n    PrefixSumComputer.prototype.changeValue = function (index, value) {\r\n        index = toUint32(index);\r\n        value = toUint32(value);\r\n        if (this.values[index] === value) {\r\n            return false;\r\n        }\r\n        this.values[index] = value;\r\n        if (index - 1 < this.prefixSumValidIndex[0]) {\r\n            this.prefixSumValidIndex[0] = index - 1;\r\n        }\r\n        return true;\r\n    };\r\n    PrefixSumComputer.prototype.removeValues = function (startIndex, cnt) {\r\n        startIndex = toUint32(startIndex);\r\n        cnt = toUint32(cnt);\r\n        var oldValues = this.values;\r\n        var oldPrefixSum = this.prefixSum;\r\n        if (startIndex >= oldValues.length) {\r\n            return false;\r\n        }\r\n        var maxCnt = oldValues.length - startIndex;\r\n        if (cnt >= maxCnt) {\r\n            cnt = maxCnt;\r\n        }\r\n        if (cnt === 0) {\r\n            return false;\r\n        }\r\n        this.values = new Uint32Array(oldValues.length - cnt);\r\n        this.values.set(oldValues.subarray(0, startIndex), 0);\r\n        this.values.set(oldValues.subarray(startIndex + cnt), startIndex);\r\n        this.prefixSum = new Uint32Array(this.values.length);\r\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\r\n            this.prefixSumValidIndex[0] = startIndex - 1;\r\n        }\r\n        if (this.prefixSumValidIndex[0] >= 0) {\r\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\r\n        }\r\n        return true;\r\n    };\r\n    PrefixSumComputer.prototype.getTotalValue = function () {\r\n        if (this.values.length === 0) {\r\n            return 0;\r\n        }\r\n        return this._getAccumulatedValue(this.values.length - 1);\r\n    };\r\n    PrefixSumComputer.prototype.getAccumulatedValue = function (index) {\r\n        if (index < 0) {\r\n            return 0;\r\n        }\r\n        index = toUint32(index);\r\n        return this._getAccumulatedValue(index);\r\n    };\r\n    PrefixSumComputer.prototype._getAccumulatedValue = function (index) {\r\n        if (index <= this.prefixSumValidIndex[0]) {\r\n            return this.prefixSum[index];\r\n        }\r\n        var startIndex = this.prefixSumValidIndex[0] + 1;\r\n        if (startIndex === 0) {\r\n            this.prefixSum[0] = this.values[0];\r\n            startIndex++;\r\n        }\r\n        if (index >= this.values.length) {\r\n            index = this.values.length - 1;\r\n        }\r\n        for (var i = startIndex; i <= index; i++) {\r\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\r\n        }\r\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\r\n        return this.prefixSum[index];\r\n    };\r\n    PrefixSumComputer.prototype.getIndexOf = function (accumulatedValue) {\r\n        accumulatedValue = Math.floor(accumulatedValue); //@perf\r\n        // Compute all sums (to get a fully valid prefixSum)\r\n        this.getTotalValue();\r\n        var low = 0;\r\n        var high = this.values.length - 1;\r\n        var mid = 0;\r\n        var midStop = 0;\r\n        var midStart = 0;\r\n        while (low <= high) {\r\n            mid = low + ((high - low) / 2) | 0;\r\n            midStop = this.prefixSum[mid];\r\n            midStart = midStop - this.values[mid];\r\n            if (accumulatedValue < midStart) {\r\n                high = mid - 1;\r\n            }\r\n            else if (accumulatedValue >= midStop) {\r\n                low = mid + 1;\r\n            }\r\n            else {\r\n                break;\r\n            }\r\n        }\r\n        return new PrefixSumIndexOfResult(mid, accumulatedValue - midStart);\r\n    };\r\n    return PrefixSumComputer;\r\n}());\r\nexport { PrefixSumComputer };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { Position } from '../core/position.js';\r\nimport { PrefixSumComputer } from '../viewModel/prefixSumComputer.js';\r\nvar MirrorTextModel = /** @class */ (function () {\r\n    function MirrorTextModel(uri, lines, eol, versionId) {\r\n        this._uri = uri;\r\n        this._lines = lines;\r\n        this._eol = eol;\r\n        this._versionId = versionId;\r\n        this._lineStarts = null;\r\n    }\r\n    MirrorTextModel.prototype.dispose = function () {\r\n        this._lines.length = 0;\r\n    };\r\n    MirrorTextModel.prototype.getText = function () {\r\n        return this._lines.join(this._eol);\r\n    };\r\n    MirrorTextModel.prototype.onEvents = function (e) {\r\n        if (e.eol && e.eol !== this._eol) {\r\n            this._eol = e.eol;\r\n            this._lineStarts = null;\r\n        }\r\n        // Update my lines\r\n        var changes = e.changes;\r\n        for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {\r\n            var change = changes_1[_i];\r\n            this._acceptDeleteRange(change.range);\r\n            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\r\n        }\r\n        this._versionId = e.versionId;\r\n    };\r\n    MirrorTextModel.prototype._ensureLineStarts = function () {\r\n        if (!this._lineStarts) {\r\n            var eolLength = this._eol.length;\r\n            var linesLength = this._lines.length;\r\n            var lineStartValues = new Uint32Array(linesLength);\r\n            for (var i = 0; i < linesLength; i++) {\r\n                lineStartValues[i] = this._lines[i].length + eolLength;\r\n            }\r\n            this._lineStarts = new PrefixSumComputer(lineStartValues);\r\n        }\r\n    };\r\n    /**\r\n     * All changes to a line's text go through this method\r\n     */\r\n    MirrorTextModel.prototype._setLineText = function (lineIndex, newValue) {\r\n        this._lines[lineIndex] = newValue;\r\n        if (this._lineStarts) {\r\n            // update prefix sum\r\n            this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\r\n        }\r\n    };\r\n    MirrorTextModel.prototype._acceptDeleteRange = function (range) {\r\n        if (range.startLineNumber === range.endLineNumber) {\r\n            if (range.startColumn === range.endColumn) {\r\n                // Nothing to delete\r\n                return;\r\n            }\r\n            // Delete text on the affected line\r\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\r\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\r\n            return;\r\n        }\r\n        // Take remaining text on last line and append it to remaining text on first line\r\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\r\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\r\n        // Delete middle lines\r\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\r\n        if (this._lineStarts) {\r\n            // update prefix sum\r\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\r\n        }\r\n    };\r\n    MirrorTextModel.prototype._acceptInsertText = function (position, insertText) {\r\n        if (insertText.length === 0) {\r\n            // Nothing to insert\r\n            return;\r\n        }\r\n        var insertLines = insertText.split(/\\r\\n|\\r|\\n/);\r\n        if (insertLines.length === 1) {\r\n            // Inserting text on one line\r\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\r\n                + insertLines[0]\r\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\r\n            return;\r\n        }\r\n        // Append overflowing text from first line to the end of text to insert\r\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\r\n        // Delete overflowing text from first line and insert text on first line\r\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\r\n            + insertLines[0]);\r\n        // Insert new lines & store lengths\r\n        var newLengths = new Uint32Array(insertLines.length - 1);\r\n        for (var i = 1; i < insertLines.length; i++) {\r\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\r\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\r\n        }\r\n        if (this._lineStarts) {\r\n            // update prefix sum\r\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\r\n        }\r\n    };\r\n    return MirrorTextModel;\r\n}());\r\nexport { MirrorTextModel };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nexport var USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\r\n/**\r\n * Create a word definition regular expression based on default word separators.\r\n * Optionally provide allowed separators that should be included in words.\r\n *\r\n * The default would look like this:\r\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\r\n */\r\nfunction createWordRegExp(allowInWords) {\r\n    if (allowInWords === void 0) { allowInWords = ''; }\r\n    var source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\r\n    for (var _i = 0, USUAL_WORD_SEPARATORS_1 = USUAL_WORD_SEPARATORS; _i < USUAL_WORD_SEPARATORS_1.length; _i++) {\r\n        var sep = USUAL_WORD_SEPARATORS_1[_i];\r\n        if (allowInWords.indexOf(sep) >= 0) {\r\n            continue;\r\n        }\r\n        source += '\\\\' + sep;\r\n    }\r\n    source += '\\\\s]+)';\r\n    return new RegExp(source, 'g');\r\n}\r\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\r\nexport var DEFAULT_WORD_REGEXP = createWordRegExp();\r\nexport function ensureValidWordDefinition(wordDefinition) {\r\n    var result = DEFAULT_WORD_REGEXP;\r\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\r\n        if (!wordDefinition.global) {\r\n            var flags = 'g';\r\n            if (wordDefinition.ignoreCase) {\r\n                flags += 'i';\r\n            }\r\n            if (wordDefinition.multiline) {\r\n                flags += 'm';\r\n            }\r\n            if (wordDefinition.unicode) {\r\n                flags += 'u';\r\n            }\r\n            result = new RegExp(wordDefinition.source, flags);\r\n        }\r\n        else {\r\n            result = wordDefinition;\r\n        }\r\n    }\r\n    result.lastIndex = 0;\r\n    return result;\r\n}\r\nfunction getWordAtPosFast(column, wordDefinition, text, textOffset) {\r\n    // find whitespace enclosed text around column and match from there\r\n    var pos = column - 1 - textOffset;\r\n    var start = text.lastIndexOf(' ', pos - 1) + 1;\r\n    wordDefinition.lastIndex = start;\r\n    var match;\r\n    while (match = wordDefinition.exec(text)) {\r\n        var matchIndex = match.index || 0;\r\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\r\n            return {\r\n                word: match[0],\r\n                startColumn: textOffset + 1 + matchIndex,\r\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\r\n            };\r\n        }\r\n    }\r\n    return null;\r\n}\r\nfunction getWordAtPosSlow(column, wordDefinition, text, textOffset) {\r\n    // matches all words starting at the beginning\r\n    // of the input until it finds a match that encloses\r\n    // the desired column. slow but correct\r\n    var pos = column - 1 - textOffset;\r\n    wordDefinition.lastIndex = 0;\r\n    var match;\r\n    while (match = wordDefinition.exec(text)) {\r\n        var matchIndex = match.index || 0;\r\n        if (matchIndex > pos) {\r\n            // |nW -> matched only after the pos\r\n            return null;\r\n        }\r\n        else if (wordDefinition.lastIndex >= pos) {\r\n            // W|W -> match encloses pos\r\n            return {\r\n                word: match[0],\r\n                startColumn: textOffset + 1 + matchIndex,\r\n                endColumn: textOffset + 1 + wordDefinition.lastIndex\r\n            };\r\n        }\r\n    }\r\n    return null;\r\n}\r\nexport function getWordAtText(column, wordDefinition, text, textOffset) {\r\n    // if `words` can contain whitespace character we have to use the slow variant\r\n    // otherwise we use the fast variant of finding a word\r\n    wordDefinition.lastIndex = 0;\r\n    var match = wordDefinition.exec(text);\r\n    if (!match) {\r\n        return null;\r\n    }\r\n    // todo@joh the `match` could already be the (first) word\r\n    var ret = match[0].indexOf(' ') >= 0\r\n        // did match a word which contains a space character -> use slow word find\r\n        ? getWordAtPosSlow(column, wordDefinition, text, textOffset)\r\n        // sane word definition -> use fast word find\r\n        : getWordAtPosFast(column, wordDefinition, text, textOffset);\r\n    // both (getWordAtPosFast and getWordAtPosSlow) leave the wordDefinition-RegExp\r\n    // in an undefined state and to not confuse other users of the wordDefinition\r\n    // we reset the lastIndex\r\n    wordDefinition.lastIndex = 0;\r\n    return ret;\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { toUint8 } from '../../../base/common/uint.js';\r\n/**\r\n * A fast character classifier that uses a compact array for ASCII values.\r\n */\r\nvar CharacterClassifier = /** @class */ (function () {\r\n    function CharacterClassifier(_defaultValue) {\r\n        var defaultValue = toUint8(_defaultValue);\r\n        this._defaultValue = defaultValue;\r\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\r\n        this._map = new Map();\r\n    }\r\n    CharacterClassifier._createAsciiMap = function (defaultValue) {\r\n        var asciiMap = new Uint8Array(256);\r\n        for (var i = 0; i < 256; i++) {\r\n            asciiMap[i] = defaultValue;\r\n        }\r\n        return asciiMap;\r\n    };\r\n    CharacterClassifier.prototype.set = function (charCode, _value) {\r\n        var value = toUint8(_value);\r\n        if (charCode >= 0 && charCode < 256) {\r\n            this._asciiMap[charCode] = value;\r\n        }\r\n        else {\r\n            this._map.set(charCode, value);\r\n        }\r\n    };\r\n    CharacterClassifier.prototype.get = function (charCode) {\r\n        if (charCode >= 0 && charCode < 256) {\r\n            return this._asciiMap[charCode];\r\n        }\r\n        else {\r\n            return (this._map.get(charCode) || this._defaultValue);\r\n        }\r\n    };\r\n    return CharacterClassifier;\r\n}());\r\nexport { CharacterClassifier };\r\nvar CharacterSet = /** @class */ (function () {\r\n    function CharacterSet() {\r\n        this._actual = new CharacterClassifier(0 /* False */);\r\n    }\r\n    CharacterSet.prototype.add = function (charCode) {\r\n        this._actual.set(charCode, 1 /* True */);\r\n    };\r\n    CharacterSet.prototype.has = function (charCode) {\r\n        return (this._actual.get(charCode) === 1 /* True */);\r\n    };\r\n    return CharacterSet;\r\n}());\r\nexport { CharacterSet };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { CharacterClassifier } from '../core/characterClassifier.js';\r\nvar Uint8Matrix = /** @class */ (function () {\r\n    function Uint8Matrix(rows, cols, defaultValue) {\r\n        var data = new Uint8Array(rows * cols);\r\n        for (var i = 0, len = rows * cols; i < len; i++) {\r\n            data[i] = defaultValue;\r\n        }\r\n        this._data = data;\r\n        this.rows = rows;\r\n        this.cols = cols;\r\n    }\r\n    Uint8Matrix.prototype.get = function (row, col) {\r\n        return this._data[row * this.cols + col];\r\n    };\r\n    Uint8Matrix.prototype.set = function (row, col, value) {\r\n        this._data[row * this.cols + col] = value;\r\n    };\r\n    return Uint8Matrix;\r\n}());\r\nexport { Uint8Matrix };\r\nvar StateMachine = /** @class */ (function () {\r\n    function StateMachine(edges) {\r\n        var maxCharCode = 0;\r\n        var maxState = 0 /* Invalid */;\r\n        for (var i = 0, len = edges.length; i < len; i++) {\r\n            var _a = edges[i], from = _a[0], chCode = _a[1], to = _a[2];\r\n            if (chCode > maxCharCode) {\r\n                maxCharCode = chCode;\r\n            }\r\n            if (from > maxState) {\r\n                maxState = from;\r\n            }\r\n            if (to > maxState) {\r\n                maxState = to;\r\n            }\r\n        }\r\n        maxCharCode++;\r\n        maxState++;\r\n        var states = new Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);\r\n        for (var i = 0, len = edges.length; i < len; i++) {\r\n            var _b = edges[i], from = _b[0], chCode = _b[1], to = _b[2];\r\n            states.set(from, chCode, to);\r\n        }\r\n        this._states = states;\r\n        this._maxCharCode = maxCharCode;\r\n    }\r\n    StateMachine.prototype.nextState = function (currentState, chCode) {\r\n        if (chCode < 0 || chCode >= this._maxCharCode) {\r\n            return 0 /* Invalid */;\r\n        }\r\n        return this._states.get(currentState, chCode);\r\n    };\r\n    return StateMachine;\r\n}());\r\nexport { StateMachine };\r\n// State machine for http:// or https:// or file://\r\nvar _stateMachine = null;\r\nfunction getStateMachine() {\r\n    if (_stateMachine === null) {\r\n        _stateMachine = new StateMachine([\r\n            [1 /* Start */, 104 /* h */, 2 /* H */],\r\n            [1 /* Start */, 72 /* H */, 2 /* H */],\r\n            [1 /* Start */, 102 /* f */, 6 /* F */],\r\n            [1 /* Start */, 70 /* F */, 6 /* F */],\r\n            [2 /* H */, 116 /* t */, 3 /* HT */],\r\n            [2 /* H */, 84 /* T */, 3 /* HT */],\r\n            [3 /* HT */, 116 /* t */, 4 /* HTT */],\r\n            [3 /* HT */, 84 /* T */, 4 /* HTT */],\r\n            [4 /* HTT */, 112 /* p */, 5 /* HTTP */],\r\n            [4 /* HTT */, 80 /* P */, 5 /* HTTP */],\r\n            [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],\r\n            [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],\r\n            [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],\r\n            [6 /* F */, 105 /* i */, 7 /* FI */],\r\n            [6 /* F */, 73 /* I */, 7 /* FI */],\r\n            [7 /* FI */, 108 /* l */, 8 /* FIL */],\r\n            [7 /* FI */, 76 /* L */, 8 /* FIL */],\r\n            [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],\r\n            [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],\r\n            [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],\r\n            [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],\r\n            [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],\r\n        ]);\r\n    }\r\n    return _stateMachine;\r\n}\r\nvar _classifier = null;\r\nfunction getClassifier() {\r\n    if (_classifier === null) {\r\n        _classifier = new CharacterClassifier(0 /* None */);\r\n        var FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…';\r\n        for (var i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\r\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);\r\n        }\r\n        var CANNOT_END_WITH_CHARACTERS = '.,;';\r\n        for (var i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\r\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);\r\n        }\r\n    }\r\n    return _classifier;\r\n}\r\nvar LinkComputer = /** @class */ (function () {\r\n    function LinkComputer() {\r\n    }\r\n    LinkComputer._createLink = function (classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\r\n        // Do not allow to end link in certain characters...\r\n        var lastIncludedCharIndex = linkEndIndex - 1;\r\n        do {\r\n            var chCode = line.charCodeAt(lastIncludedCharIndex);\r\n            var chClass = classifier.get(chCode);\r\n            if (chClass !== 2 /* CannotEndIn */) {\r\n                break;\r\n            }\r\n            lastIncludedCharIndex--;\r\n        } while (lastIncludedCharIndex > linkBeginIndex);\r\n        // Handle links enclosed in parens, square brackets and curlys.\r\n        if (linkBeginIndex > 0) {\r\n            var charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\r\n            var lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\r\n            if ((charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */)\r\n                || (charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */)\r\n                || (charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */)) {\r\n                // Do not end in ) if ( is before the link start\r\n                // Do not end in ] if [ is before the link start\r\n                // Do not end in } if { is before the link start\r\n                lastIncludedCharIndex--;\r\n            }\r\n        }\r\n        return {\r\n            range: {\r\n                startLineNumber: lineNumber,\r\n                startColumn: linkBeginIndex + 1,\r\n                endLineNumber: lineNumber,\r\n                endColumn: lastIncludedCharIndex + 2\r\n            },\r\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\r\n        };\r\n    };\r\n    LinkComputer.computeLinks = function (model, stateMachine) {\r\n        if (stateMachine === void 0) { stateMachine = getStateMachine(); }\r\n        var classifier = getClassifier();\r\n        var result = [];\r\n        for (var i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\r\n            var line = model.getLineContent(i);\r\n            var len = line.length;\r\n            var j = 0;\r\n            var linkBeginIndex = 0;\r\n            var linkBeginChCode = 0;\r\n            var state = 1 /* Start */;\r\n            var hasOpenParens = false;\r\n            var hasOpenSquareBracket = false;\r\n            var hasOpenCurlyBracket = false;\r\n            while (j < len) {\r\n                var resetStateMachine = false;\r\n                var chCode = line.charCodeAt(j);\r\n                if (state === 13 /* Accept */) {\r\n                    var chClass = void 0;\r\n                    switch (chCode) {\r\n                        case 40 /* OpenParen */:\r\n                            hasOpenParens = true;\r\n                            chClass = 0 /* None */;\r\n                            break;\r\n                        case 41 /* CloseParen */:\r\n                            chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);\r\n                            break;\r\n                        case 91 /* OpenSquareBracket */:\r\n                            hasOpenSquareBracket = true;\r\n                            chClass = 0 /* None */;\r\n                            break;\r\n                        case 93 /* CloseSquareBracket */:\r\n                            chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);\r\n                            break;\r\n                        case 123 /* OpenCurlyBrace */:\r\n                            hasOpenCurlyBracket = true;\r\n                            chClass = 0 /* None */;\r\n                            break;\r\n                        case 125 /* CloseCurlyBrace */:\r\n                            chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);\r\n                            break;\r\n                        /* The following three rules make it that ' or \" or ` are allowed inside links if the link began with a different one */\r\n                        case 39 /* SingleQuote */:\r\n                            chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\r\n                            break;\r\n                        case 34 /* DoubleQuote */:\r\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\r\n                            break;\r\n                        case 96 /* BackTick */:\r\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;\r\n                            break;\r\n                        case 42 /* Asterisk */:\r\n                            // `*` terminates a link if the link began with `*`\r\n                            chClass = (linkBeginChCode === 42 /* Asterisk */) ? 1 /* ForceTermination */ : 0 /* None */;\r\n                            break;\r\n                        case 124 /* Pipe */:\r\n                            // `|` terminates a link if the link began with `|`\r\n                            chClass = (linkBeginChCode === 124 /* Pipe */) ? 1 /* ForceTermination */ : 0 /* None */;\r\n                            break;\r\n                        default:\r\n                            chClass = classifier.get(chCode);\r\n                    }\r\n                    // Check if character terminates link\r\n                    if (chClass === 1 /* ForceTermination */) {\r\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\r\n                        resetStateMachine = true;\r\n                    }\r\n                }\r\n                else if (state === 12 /* End */) {\r\n                    var chClass = void 0;\r\n                    if (chCode === 91 /* OpenSquareBracket */) {\r\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\r\n                        hasOpenSquareBracket = true;\r\n                        chClass = 0 /* None */;\r\n                    }\r\n                    else {\r\n                        chClass = classifier.get(chCode);\r\n                    }\r\n                    // Check if character terminates link\r\n                    if (chClass === 1 /* ForceTermination */) {\r\n                        resetStateMachine = true;\r\n                    }\r\n                    else {\r\n                        state = 13 /* Accept */;\r\n                    }\r\n                }\r\n                else {\r\n                    state = stateMachine.nextState(state, chCode);\r\n                    if (state === 0 /* Invalid */) {\r\n                        resetStateMachine = true;\r\n                    }\r\n                }\r\n                if (resetStateMachine) {\r\n                    state = 1 /* Start */;\r\n                    hasOpenParens = false;\r\n                    hasOpenSquareBracket = false;\r\n                    hasOpenCurlyBracket = false;\r\n                    // Record where the link started\r\n                    linkBeginIndex = j + 1;\r\n                    linkBeginChCode = chCode;\r\n                }\r\n                j++;\r\n            }\r\n            if (state === 13 /* Accept */) {\r\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\r\n            }\r\n        }\r\n        return result;\r\n    };\r\n    return LinkComputer;\r\n}());\r\nexport { LinkComputer };\r\n/**\r\n * Returns an array of all links contains in the provided\r\n * document. *Note* that this operation is computational\r\n * expensive and should not run in the UI thread.\r\n */\r\nexport function computeLinks(model) {\r\n    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\r\n        // Unknown caller!\r\n        return [];\r\n    }\r\n    return LinkComputer.computeLinks(model);\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar BasicInplaceReplace = /** @class */ (function () {\r\n    function BasicInplaceReplace() {\r\n        this._defaultValueSet = [\r\n            ['true', 'false'],\r\n            ['True', 'False'],\r\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\r\n            ['public', 'protected', 'private'],\r\n        ];\r\n    }\r\n    BasicInplaceReplace.prototype.navigateValueSet = function (range1, text1, range2, text2, up) {\r\n        if (range1 && text1) {\r\n            var result = this.doNavigateValueSet(text1, up);\r\n            if (result) {\r\n                return {\r\n                    range: range1,\r\n                    value: result\r\n                };\r\n            }\r\n        }\r\n        if (range2 && text2) {\r\n            var result = this.doNavigateValueSet(text2, up);\r\n            if (result) {\r\n                return {\r\n                    range: range2,\r\n                    value: result\r\n                };\r\n            }\r\n        }\r\n        return null;\r\n    };\r\n    BasicInplaceReplace.prototype.doNavigateValueSet = function (text, up) {\r\n        var numberResult = this.numberReplace(text, up);\r\n        if (numberResult !== null) {\r\n            return numberResult;\r\n        }\r\n        return this.textReplace(text, up);\r\n    };\r\n    BasicInplaceReplace.prototype.numberReplace = function (value, up) {\r\n        var precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\r\n        var n1 = Number(value);\r\n        var n2 = parseFloat(value);\r\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\r\n            if (n1 === 0 && !up) {\r\n                return null; // don't do negative\r\n                //\t\t\t} else if(n1 === 9 && up) {\r\n                //\t\t\t\treturn null; // don't insert 10 into a number\r\n            }\r\n            else {\r\n                n1 = Math.floor(n1 * precision);\r\n                n1 += up ? precision : -precision;\r\n                return String(n1 / precision);\r\n            }\r\n        }\r\n        return null;\r\n    };\r\n    BasicInplaceReplace.prototype.textReplace = function (value, up) {\r\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\r\n    };\r\n    BasicInplaceReplace.prototype.valueSetsReplace = function (valueSets, value, up) {\r\n        var result = null;\r\n        for (var i = 0, len = valueSets.length; result === null && i < len; i++) {\r\n            result = this.valueSetReplace(valueSets[i], value, up);\r\n        }\r\n        return result;\r\n    };\r\n    BasicInplaceReplace.prototype.valueSetReplace = function (valueSet, value, up) {\r\n        var idx = valueSet.indexOf(value);\r\n        if (idx >= 0) {\r\n            idx += up ? +1 : -1;\r\n            if (idx < 0) {\r\n                idx = valueSet.length - 1;\r\n            }\r\n            else {\r\n                idx %= valueSet.length;\r\n            }\r\n            return valueSet[idx];\r\n        }\r\n        return null;\r\n    };\r\n    BasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\r\n    return BasicInplaceReplace;\r\n}());\r\nexport { BasicInplaceReplace };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nexport function once(fn) {\r\n    var _this = this;\r\n    var didCall = false;\r\n    var result;\r\n    return function () {\r\n        if (didCall) {\r\n            return result;\r\n        }\r\n        didCall = true;\r\n        result = fn.apply(_this, arguments);\r\n        return result;\r\n    };\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { FIN } from './iterator.js';\r\nvar Node = /** @class */ (function () {\r\n    function Node(element) {\r\n        this.element = element;\r\n        this.next = Node.Undefined;\r\n        this.prev = Node.Undefined;\r\n    }\r\n    Node.Undefined = new Node(undefined);\r\n    return Node;\r\n}());\r\nvar LinkedList = /** @class */ (function () {\r\n    function LinkedList() {\r\n        this._first = Node.Undefined;\r\n        this._last = Node.Undefined;\r\n        this._size = 0;\r\n    }\r\n    Object.defineProperty(LinkedList.prototype, \"size\", {\r\n        get: function () {\r\n            return this._size;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    LinkedList.prototype.isEmpty = function () {\r\n        return this._first === Node.Undefined;\r\n    };\r\n    LinkedList.prototype.clear = function () {\r\n        this._first = Node.Undefined;\r\n        this._last = Node.Undefined;\r\n        this._size = 0;\r\n    };\r\n    LinkedList.prototype.unshift = function (element) {\r\n        return this._insert(element, false);\r\n    };\r\n    LinkedList.prototype.push = function (element) {\r\n        return this._insert(element, true);\r\n    };\r\n    LinkedList.prototype._insert = function (element, atTheEnd) {\r\n        var _this = this;\r\n        var newNode = new Node(element);\r\n        if (this._first === Node.Undefined) {\r\n            this._first = newNode;\r\n            this._last = newNode;\r\n        }\r\n        else if (atTheEnd) {\r\n            // push\r\n            var oldLast = this._last;\r\n            this._last = newNode;\r\n            newNode.prev = oldLast;\r\n            oldLast.next = newNode;\r\n        }\r\n        else {\r\n            // unshift\r\n            var oldFirst = this._first;\r\n            this._first = newNode;\r\n            newNode.next = oldFirst;\r\n            oldFirst.prev = newNode;\r\n        }\r\n        this._size += 1;\r\n        var didRemove = false;\r\n        return function () {\r\n            if (!didRemove) {\r\n                didRemove = true;\r\n                _this._remove(newNode);\r\n            }\r\n        };\r\n    };\r\n    LinkedList.prototype.shift = function () {\r\n        if (this._first === Node.Undefined) {\r\n            return undefined;\r\n        }\r\n        else {\r\n            var res = this._first.element;\r\n            this._remove(this._first);\r\n            return res;\r\n        }\r\n    };\r\n    LinkedList.prototype.pop = function () {\r\n        if (this._last === Node.Undefined) {\r\n            return undefined;\r\n        }\r\n        else {\r\n            var res = this._last.element;\r\n            this._remove(this._last);\r\n            return res;\r\n        }\r\n    };\r\n    LinkedList.prototype._remove = function (node) {\r\n        if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {\r\n            // middle\r\n            var anchor = node.prev;\r\n            anchor.next = node.next;\r\n            node.next.prev = anchor;\r\n        }\r\n        else if (node.prev === Node.Undefined && node.next === Node.Undefined) {\r\n            // only node\r\n            this._first = Node.Undefined;\r\n            this._last = Node.Undefined;\r\n        }\r\n        else if (node.next === Node.Undefined) {\r\n            // last\r\n            this._last = this._last.prev;\r\n            this._last.next = Node.Undefined;\r\n        }\r\n        else if (node.prev === Node.Undefined) {\r\n            // first\r\n            this._first = this._first.next;\r\n            this._first.prev = Node.Undefined;\r\n        }\r\n        // done\r\n        this._size -= 1;\r\n    };\r\n    LinkedList.prototype.iterator = function () {\r\n        var element;\r\n        var node = this._first;\r\n        return {\r\n            next: function () {\r\n                if (node === Node.Undefined) {\r\n                    return FIN;\r\n                }\r\n                if (!element) {\r\n                    element = { done: false, value: node.element };\r\n                }\r\n                else {\r\n                    element.value = node.element;\r\n                }\r\n                node = node.next;\r\n                return element;\r\n            }\r\n        };\r\n    };\r\n    LinkedList.prototype.toArray = function () {\r\n        var result = [];\r\n        for (var node = this._first; node !== Node.Undefined; node = node.next) {\r\n            result.push(node.element);\r\n        }\r\n        return result;\r\n    };\r\n    return LinkedList;\r\n}());\r\nexport { LinkedList };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nimport { onUnexpectedError } from './errors.js';\r\nimport { once as onceFn } from './functional.js';\r\nimport { Disposable, toDisposable, combinedDisposable, DisposableStore } from './lifecycle.js';\r\nimport { LinkedList } from './linkedList.js';\r\nexport var Event;\r\n(function (Event) {\r\n    Event.None = function () { return Disposable.None; };\r\n    /**\r\n     * Given an event, returns another event which only fires once.\r\n     */\r\n    function once(event) {\r\n        return function (listener, thisArgs, disposables) {\r\n            if (thisArgs === void 0) { thisArgs = null; }\r\n            // we need this, in case the event fires during the listener call\r\n            var didFire = false;\r\n            var result;\r\n            result = event(function (e) {\r\n                if (didFire) {\r\n                    return;\r\n                }\r\n                else if (result) {\r\n                    result.dispose();\r\n                }\r\n                else {\r\n                    didFire = true;\r\n                }\r\n                return listener.call(thisArgs, e);\r\n            }, null, disposables);\r\n            if (didFire) {\r\n                result.dispose();\r\n            }\r\n            return result;\r\n        };\r\n    }\r\n    Event.once = once;\r\n    /**\r\n     * Given an event and a `map` function, returns another event which maps each element\r\n     * through the mapping function.\r\n     */\r\n    function map(event, map) {\r\n        return snapshot(function (listener, thisArgs, disposables) {\r\n            if (thisArgs === void 0) { thisArgs = null; }\r\n            return event(function (i) { return listener.call(thisArgs, map(i)); }, null, disposables);\r\n        });\r\n    }\r\n    Event.map = map;\r\n    /**\r\n     * Given an event and an `each` function, returns another identical event and calls\r\n     * the `each` function per each element.\r\n     */\r\n    function forEach(event, each) {\r\n        return snapshot(function (listener, thisArgs, disposables) {\r\n            if (thisArgs === void 0) { thisArgs = null; }\r\n            return event(function (i) { each(i); listener.call(thisArgs, i); }, null, disposables);\r\n        });\r\n    }\r\n    Event.forEach = forEach;\r\n    function filter(event, filter) {\r\n        return snapshot(function (listener, thisArgs, disposables) {\r\n            if (thisArgs === void 0) { thisArgs = null; }\r\n            return event(function (e) { return filter(e) && listener.call(thisArgs, e); }, null, disposables);\r\n        });\r\n    }\r\n    Event.filter = filter;\r\n    /**\r\n     * Given an event, returns the same event but typed as `Event<void>`.\r\n     */\r\n    function signal(event) {\r\n        return event;\r\n    }\r\n    Event.signal = signal;\r\n    /**\r\n     * Given a collection of events, returns a single event which emits\r\n     * whenever any of the provided events emit.\r\n     */\r\n    function any() {\r\n        var events = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            events[_i] = arguments[_i];\r\n        }\r\n        return function (listener, thisArgs, disposables) {\r\n            if (thisArgs === void 0) { thisArgs = null; }\r\n            return combinedDisposable.apply(void 0, events.map(function (event) { return event(function (e) { return listener.call(thisArgs, e); }, null, disposables); }));\r\n        };\r\n    }\r\n    Event.any = any;\r\n    /**\r\n     * Given an event and a `merge` function, returns another event which maps each element\r\n     * and the cumulative result through the `merge` function. Similar to `map`, but with memory.\r\n     */\r\n    function reduce(event, merge, initial) {\r\n        var output = initial;\r\n        return map(event, function (e) {\r\n            output = merge(output, e);\r\n            return output;\r\n        });\r\n    }\r\n    Event.reduce = reduce;\r\n    /**\r\n     * Given a chain of event processing functions (filter, map, etc), each\r\n     * function will be invoked per event & per listener. Snapshotting an event\r\n     * chain allows each function to be invoked just once per event.\r\n     */\r\n    function snapshot(event) {\r\n        var listener;\r\n        var emitter = new Emitter({\r\n            onFirstListenerAdd: function () {\r\n                listener = event(emitter.fire, emitter);\r\n            },\r\n            onLastListenerRemove: function () {\r\n                listener.dispose();\r\n            }\r\n        });\r\n        return emitter.event;\r\n    }\r\n    Event.snapshot = snapshot;\r\n    function debounce(event, merge, delay, leading, leakWarningThreshold) {\r\n        if (delay === void 0) { delay = 100; }\r\n        if (leading === void 0) { leading = false; }\r\n        var subscription;\r\n        var output = undefined;\r\n        var handle = undefined;\r\n        var numDebouncedCalls = 0;\r\n        var emitter = new Emitter({\r\n            leakWarningThreshold: leakWarningThreshold,\r\n            onFirstListenerAdd: function () {\r\n                subscription = event(function (cur) {\r\n                    numDebouncedCalls++;\r\n                    output = merge(output, cur);\r\n                    if (leading && !handle) {\r\n                        emitter.fire(output);\r\n                        output = undefined;\r\n                    }\r\n                    clearTimeout(handle);\r\n                    handle = setTimeout(function () {\r\n                        var _output = output;\r\n                        output = undefined;\r\n                        handle = undefined;\r\n                        if (!leading || numDebouncedCalls > 1) {\r\n                            emitter.fire(_output);\r\n                        }\r\n                        numDebouncedCalls = 0;\r\n                    }, delay);\r\n                });\r\n            },\r\n            onLastListenerRemove: function () {\r\n                subscription.dispose();\r\n            }\r\n        });\r\n        return emitter.event;\r\n    }\r\n    Event.debounce = debounce;\r\n    /**\r\n     * Given an event, it returns another event which fires only once and as soon as\r\n     * the input event emits. The event data is the number of millis it took for the\r\n     * event to fire.\r\n     */\r\n    function stopwatch(event) {\r\n        var start = new Date().getTime();\r\n        return map(once(event), function (_) { return new Date().getTime() - start; });\r\n    }\r\n    Event.stopwatch = stopwatch;\r\n    /**\r\n     * Given an event, it returns another event which fires only when the event\r\n     * element changes.\r\n     */\r\n    function latch(event) {\r\n        var firstCall = true;\r\n        var cache;\r\n        return filter(event, function (value) {\r\n            var shouldEmit = firstCall || value !== cache;\r\n            firstCall = false;\r\n            cache = value;\r\n            return shouldEmit;\r\n        });\r\n    }\r\n    Event.latch = latch;\r\n    /**\r\n     * Buffers the provided event until a first listener comes\r\n     * along, at which point fire all the events at once and\r\n     * pipe the event from then on.\r\n     *\r\n     * ```typescript\r\n     * const emitter = new Emitter<number>();\r\n     * const event = emitter.event;\r\n     * const bufferedEvent = buffer(event);\r\n     *\r\n     * emitter.fire(1);\r\n     * emitter.fire(2);\r\n     * emitter.fire(3);\r\n     * // nothing...\r\n     *\r\n     * const listener = bufferedEvent(num => console.log(num));\r\n     * // 1, 2, 3\r\n     *\r\n     * emitter.fire(4);\r\n     * // 4\r\n     * ```\r\n     */\r\n    function buffer(event, nextTick, _buffer) {\r\n        if (nextTick === void 0) { nextTick = false; }\r\n        if (_buffer === void 0) { _buffer = []; }\r\n        var buffer = _buffer.slice();\r\n        var listener = event(function (e) {\r\n            if (buffer) {\r\n                buffer.push(e);\r\n            }\r\n            else {\r\n                emitter.fire(e);\r\n            }\r\n        });\r\n        var flush = function () {\r\n            if (buffer) {\r\n                buffer.forEach(function (e) { return emitter.fire(e); });\r\n            }\r\n            buffer = null;\r\n        };\r\n        var emitter = new Emitter({\r\n            onFirstListenerAdd: function () {\r\n                if (!listener) {\r\n                    listener = event(function (e) { return emitter.fire(e); });\r\n                }\r\n            },\r\n            onFirstListenerDidAdd: function () {\r\n                if (buffer) {\r\n                    if (nextTick) {\r\n                        setTimeout(flush);\r\n                    }\r\n                    else {\r\n                        flush();\r\n                    }\r\n                }\r\n            },\r\n            onLastListenerRemove: function () {\r\n                if (listener) {\r\n                    listener.dispose();\r\n                }\r\n                listener = null;\r\n            }\r\n        });\r\n        return emitter.event;\r\n    }\r\n    Event.buffer = buffer;\r\n    var ChainableEvent = /** @class */ (function () {\r\n        function ChainableEvent(event) {\r\n            this.event = event;\r\n        }\r\n        ChainableEvent.prototype.map = function (fn) {\r\n            return new ChainableEvent(map(this.event, fn));\r\n        };\r\n        ChainableEvent.prototype.forEach = function (fn) {\r\n            return new ChainableEvent(forEach(this.event, fn));\r\n        };\r\n        ChainableEvent.prototype.filter = function (fn) {\r\n            return new ChainableEvent(filter(this.event, fn));\r\n        };\r\n        ChainableEvent.prototype.reduce = function (merge, initial) {\r\n            return new ChainableEvent(reduce(this.event, merge, initial));\r\n        };\r\n        ChainableEvent.prototype.latch = function () {\r\n            return new ChainableEvent(latch(this.event));\r\n        };\r\n        ChainableEvent.prototype.debounce = function (merge, delay, leading, leakWarningThreshold) {\r\n            if (delay === void 0) { delay = 100; }\r\n            if (leading === void 0) { leading = false; }\r\n            return new ChainableEvent(debounce(this.event, merge, delay, leading, leakWarningThreshold));\r\n        };\r\n        ChainableEvent.prototype.on = function (listener, thisArgs, disposables) {\r\n            return this.event(listener, thisArgs, disposables);\r\n        };\r\n        ChainableEvent.prototype.once = function (listener, thisArgs, disposables) {\r\n            return once(this.event)(listener, thisArgs, disposables);\r\n        };\r\n        return ChainableEvent;\r\n    }());\r\n    function chain(event) {\r\n        return new ChainableEvent(event);\r\n    }\r\n    Event.chain = chain;\r\n    function fromNodeEventEmitter(emitter, eventName, map) {\r\n        if (map === void 0) { map = function (id) { return id; }; }\r\n        var fn = function () {\r\n            var args = [];\r\n            for (var _i = 0; _i < arguments.length; _i++) {\r\n                args[_i] = arguments[_i];\r\n            }\r\n            return result.fire(map.apply(void 0, args));\r\n        };\r\n        var onFirstListenerAdd = function () { return emitter.on(eventName, fn); };\r\n        var onLastListenerRemove = function () { return emitter.removeListener(eventName, fn); };\r\n        var result = new Emitter({ onFirstListenerAdd: onFirstListenerAdd, onLastListenerRemove: onLastListenerRemove });\r\n        return result.event;\r\n    }\r\n    Event.fromNodeEventEmitter = fromNodeEventEmitter;\r\n    function fromDOMEventEmitter(emitter, eventName, map) {\r\n        if (map === void 0) { map = function (id) { return id; }; }\r\n        var fn = function () {\r\n            var args = [];\r\n            for (var _i = 0; _i < arguments.length; _i++) {\r\n                args[_i] = arguments[_i];\r\n            }\r\n            return result.fire(map.apply(void 0, args));\r\n        };\r\n        var onFirstListenerAdd = function () { return emitter.addEventListener(eventName, fn); };\r\n        var onLastListenerRemove = function () { return emitter.removeEventListener(eventName, fn); };\r\n        var result = new Emitter({ onFirstListenerAdd: onFirstListenerAdd, onLastListenerRemove: onLastListenerRemove });\r\n        return result.event;\r\n    }\r\n    Event.fromDOMEventEmitter = fromDOMEventEmitter;\r\n    function fromPromise(promise) {\r\n        var emitter = new Emitter();\r\n        var shouldEmit = false;\r\n        promise\r\n            .then(undefined, function () { return null; })\r\n            .then(function () {\r\n            if (!shouldEmit) {\r\n                setTimeout(function () { return emitter.fire(undefined); }, 0);\r\n            }\r\n            else {\r\n                emitter.fire(undefined);\r\n            }\r\n        });\r\n        shouldEmit = true;\r\n        return emitter.event;\r\n    }\r\n    Event.fromPromise = fromPromise;\r\n    function toPromise(event) {\r\n        return new Promise(function (c) { return once(event)(c); });\r\n    }\r\n    Event.toPromise = toPromise;\r\n})(Event || (Event = {}));\r\nvar _globalLeakWarningThreshold = -1;\r\nvar LeakageMonitor = /** @class */ (function () {\r\n    function LeakageMonitor(customThreshold, name) {\r\n        if (name === void 0) { name = Math.random().toString(18).slice(2, 5); }\r\n        this.customThreshold = customThreshold;\r\n        this.name = name;\r\n        this._warnCountdown = 0;\r\n    }\r\n    LeakageMonitor.prototype.dispose = function () {\r\n        if (this._stacks) {\r\n            this._stacks.clear();\r\n        }\r\n    };\r\n    LeakageMonitor.prototype.check = function (listenerCount) {\r\n        var _this = this;\r\n        var threshold = _globalLeakWarningThreshold;\r\n        if (typeof this.customThreshold === 'number') {\r\n            threshold = this.customThreshold;\r\n        }\r\n        if (threshold <= 0 || listenerCount < threshold) {\r\n            return undefined;\r\n        }\r\n        if (!this._stacks) {\r\n            this._stacks = new Map();\r\n        }\r\n        var stack = new Error().stack.split('\\n').slice(3).join('\\n');\r\n        var count = (this._stacks.get(stack) || 0);\r\n        this._stacks.set(stack, count + 1);\r\n        this._warnCountdown -= 1;\r\n        if (this._warnCountdown <= 0) {\r\n            // only warn on first exceed and then every time the limit\r\n            // is exceeded by 50% again\r\n            this._warnCountdown = threshold * 0.5;\r\n            // find most frequent listener and print warning\r\n            var topStack_1;\r\n            var topCount_1 = 0;\r\n            this._stacks.forEach(function (count, stack) {\r\n                if (!topStack_1 || topCount_1 < count) {\r\n                    topStack_1 = stack;\r\n                    topCount_1 = count;\r\n                }\r\n            });\r\n            console.warn(\"[\" + this.name + \"] potential listener LEAK detected, having \" + listenerCount + \" listeners already. MOST frequent listener (\" + topCount_1 + \"):\");\r\n            console.warn(topStack_1);\r\n        }\r\n        return function () {\r\n            var count = (_this._stacks.get(stack) || 0);\r\n            _this._stacks.set(stack, count - 1);\r\n        };\r\n    };\r\n    return LeakageMonitor;\r\n}());\r\n/**\r\n * The Emitter can be used to expose an Event to the public\r\n * to fire it from the insides.\r\n * Sample:\r\n    class Document {\r\n\r\n        private readonly _onDidChange = new Emitter<(value:string)=>any>();\r\n\r\n        public onDidChange = this._onDidChange.event;\r\n\r\n        // getter-style\r\n        // get onDidChange(): Event<(value:string)=>any> {\r\n        // \treturn this._onDidChange.event;\r\n        // }\r\n\r\n        private _doIt() {\r\n            //...\r\n            this._onDidChange.fire(value);\r\n        }\r\n    }\r\n */\r\nvar Emitter = /** @class */ (function () {\r\n    function Emitter(options) {\r\n        this._disposed = false;\r\n        this._options = options;\r\n        this._leakageMon = _globalLeakWarningThreshold > 0\r\n            ? new LeakageMonitor(this._options && this._options.leakWarningThreshold)\r\n            : undefined;\r\n    }\r\n    Object.defineProperty(Emitter.prototype, \"event\", {\r\n        /**\r\n         * For the public to allow to subscribe\r\n         * to events from this Emitter\r\n         */\r\n        get: function () {\r\n            var _this = this;\r\n            if (!this._event) {\r\n                this._event = function (listener, thisArgs, disposables) {\r\n                    if (!_this._listeners) {\r\n                        _this._listeners = new LinkedList();\r\n                    }\r\n                    var firstListener = _this._listeners.isEmpty();\r\n                    if (firstListener && _this._options && _this._options.onFirstListenerAdd) {\r\n                        _this._options.onFirstListenerAdd(_this);\r\n                    }\r\n                    var remove = _this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\r\n                    if (firstListener && _this._options && _this._options.onFirstListenerDidAdd) {\r\n                        _this._options.onFirstListenerDidAdd(_this);\r\n                    }\r\n                    if (_this._options && _this._options.onListenerDidAdd) {\r\n                        _this._options.onListenerDidAdd(_this, listener, thisArgs);\r\n                    }\r\n                    // check and record this emitter for potential leakage\r\n                    var removeMonitor;\r\n                    if (_this._leakageMon) {\r\n                        removeMonitor = _this._leakageMon.check(_this._listeners.size);\r\n                    }\r\n                    var result;\r\n                    result = {\r\n                        dispose: function () {\r\n                            if (removeMonitor) {\r\n                                removeMonitor();\r\n                            }\r\n                            result.dispose = Emitter._noop;\r\n                            if (!_this._disposed) {\r\n                                remove();\r\n                                if (_this._options && _this._options.onLastListenerRemove) {\r\n                                    var hasListeners = (_this._listeners && !_this._listeners.isEmpty());\r\n                                    if (!hasListeners) {\r\n                                        _this._options.onLastListenerRemove(_this);\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                    };\r\n                    if (disposables instanceof DisposableStore) {\r\n                        disposables.add(result);\r\n                    }\r\n                    else if (Array.isArray(disposables)) {\r\n                        disposables.push(result);\r\n                    }\r\n                    return result;\r\n                };\r\n            }\r\n            return this._event;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    /**\r\n     * To be kept private to fire an event to\r\n     * subscribers\r\n     */\r\n    Emitter.prototype.fire = function (event) {\r\n        if (this._listeners) {\r\n            // put all [listener,event]-pairs into delivery queue\r\n            // then emit all event. an inner/nested event might be\r\n            // the driver of this\r\n            if (!this._deliveryQueue) {\r\n                this._deliveryQueue = new LinkedList();\r\n            }\r\n            for (var iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {\r\n                this._deliveryQueue.push([e.value, event]);\r\n            }\r\n            while (this._deliveryQueue.size > 0) {\r\n                var _a = this._deliveryQueue.shift(), listener = _a[0], event_1 = _a[1];\r\n                try {\r\n                    if (typeof listener === 'function') {\r\n                        listener.call(undefined, event_1);\r\n                    }\r\n                    else {\r\n                        listener[0].call(listener[1], event_1);\r\n                    }\r\n                }\r\n                catch (e) {\r\n                    onUnexpectedError(e);\r\n                }\r\n            }\r\n        }\r\n    };\r\n    Emitter.prototype.dispose = function () {\r\n        if (this._listeners) {\r\n            this._listeners.clear();\r\n        }\r\n        if (this._deliveryQueue) {\r\n            this._deliveryQueue.clear();\r\n        }\r\n        if (this._leakageMon) {\r\n            this._leakageMon.dispose();\r\n        }\r\n        this._disposed = true;\r\n    };\r\n    Emitter._noop = function () { };\r\n    return Emitter;\r\n}());\r\nexport { Emitter };\r\nvar PauseableEmitter = /** @class */ (function (_super) {\r\n    __extends(PauseableEmitter, _super);\r\n    function PauseableEmitter(options) {\r\n        var _this = _super.call(this, options) || this;\r\n        _this._isPaused = 0;\r\n        _this._eventQueue = new LinkedList();\r\n        _this._mergeFn = options && options.merge;\r\n        return _this;\r\n    }\r\n    PauseableEmitter.prototype.pause = function () {\r\n        this._isPaused++;\r\n    };\r\n    PauseableEmitter.prototype.resume = function () {\r\n        if (this._isPaused !== 0 && --this._isPaused === 0) {\r\n            if (this._mergeFn) {\r\n                // use the merge function to create a single composite\r\n                // event. make a copy in case firing pauses this emitter\r\n                var events = this._eventQueue.toArray();\r\n                this._eventQueue.clear();\r\n                _super.prototype.fire.call(this, this._mergeFn(events));\r\n            }\r\n            else {\r\n                // no merging, fire each event individually and test\r\n                // that this emitter isn't paused halfway through\r\n                while (!this._isPaused && this._eventQueue.size !== 0) {\r\n                    _super.prototype.fire.call(this, this._eventQueue.shift());\r\n                }\r\n            }\r\n        }\r\n    };\r\n    PauseableEmitter.prototype.fire = function (event) {\r\n        if (this._listeners) {\r\n            if (this._isPaused !== 0) {\r\n                this._eventQueue.push(event);\r\n            }\r\n            else {\r\n                _super.prototype.fire.call(this, event);\r\n            }\r\n        }\r\n    };\r\n    return PauseableEmitter;\r\n}(Emitter));\r\nexport { PauseableEmitter };\r\nvar EventMultiplexer = /** @class */ (function () {\r\n    function EventMultiplexer() {\r\n        var _this = this;\r\n        this.hasListeners = false;\r\n        this.events = [];\r\n        this.emitter = new Emitter({\r\n            onFirstListenerAdd: function () { return _this.onFirstListenerAdd(); },\r\n            onLastListenerRemove: function () { return _this.onLastListenerRemove(); }\r\n        });\r\n    }\r\n    Object.defineProperty(EventMultiplexer.prototype, \"event\", {\r\n        get: function () {\r\n            return this.emitter.event;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    EventMultiplexer.prototype.add = function (event) {\r\n        var _this = this;\r\n        var e = { event: event, listener: null };\r\n        this.events.push(e);\r\n        if (this.hasListeners) {\r\n            this.hook(e);\r\n        }\r\n        var dispose = function () {\r\n            if (_this.hasListeners) {\r\n                _this.unhook(e);\r\n            }\r\n            var idx = _this.events.indexOf(e);\r\n            _this.events.splice(idx, 1);\r\n        };\r\n        return toDisposable(onceFn(dispose));\r\n    };\r\n    EventMultiplexer.prototype.onFirstListenerAdd = function () {\r\n        var _this = this;\r\n        this.hasListeners = true;\r\n        this.events.forEach(function (e) { return _this.hook(e); });\r\n    };\r\n    EventMultiplexer.prototype.onLastListenerRemove = function () {\r\n        var _this = this;\r\n        this.hasListeners = false;\r\n        this.events.forEach(function (e) { return _this.unhook(e); });\r\n    };\r\n    EventMultiplexer.prototype.hook = function (e) {\r\n        var _this = this;\r\n        e.listener = e.event(function (r) { return _this.emitter.fire(r); });\r\n    };\r\n    EventMultiplexer.prototype.unhook = function (e) {\r\n        if (e.listener) {\r\n            e.listener.dispose();\r\n        }\r\n        e.listener = null;\r\n    };\r\n    EventMultiplexer.prototype.dispose = function () {\r\n        this.emitter.dispose();\r\n    };\r\n    return EventMultiplexer;\r\n}());\r\nexport { EventMultiplexer };\r\n/**\r\n * The EventBufferer is useful in situations in which you want\r\n * to delay firing your events during some code.\r\n * You can wrap that code and be sure that the event will not\r\n * be fired during that wrap.\r\n *\r\n * ```\r\n * const emitter: Emitter;\r\n * const delayer = new EventDelayer();\r\n * const delayedEvent = delayer.wrapEvent(emitter.event);\r\n *\r\n * delayedEvent(console.log);\r\n *\r\n * delayer.bufferEvents(() => {\r\n *   emitter.fire(); // event will not be fired yet\r\n * });\r\n *\r\n * // event will only be fired at this point\r\n * ```\r\n */\r\nvar EventBufferer = /** @class */ (function () {\r\n    function EventBufferer() {\r\n        this.buffers = [];\r\n    }\r\n    EventBufferer.prototype.wrapEvent = function (event) {\r\n        var _this = this;\r\n        return function (listener, thisArgs, disposables) {\r\n            return event(function (i) {\r\n                var buffer = _this.buffers[_this.buffers.length - 1];\r\n                if (buffer) {\r\n                    buffer.push(function () { return listener.call(thisArgs, i); });\r\n                }\r\n                else {\r\n                    listener.call(thisArgs, i);\r\n                }\r\n            }, undefined, disposables);\r\n        };\r\n    };\r\n    EventBufferer.prototype.bufferEvents = function (fn) {\r\n        var buffer = [];\r\n        this.buffers.push(buffer);\r\n        var r = fn();\r\n        this.buffers.pop();\r\n        buffer.forEach(function (flush) { return flush(); });\r\n        return r;\r\n    };\r\n    return EventBufferer;\r\n}());\r\nexport { EventBufferer };\r\n/**\r\n * A Relay is an event forwarder which functions as a replugabble event pipe.\r\n * Once created, you can connect an input event to it and it will simply forward\r\n * events from that input event through its own `event` property. The `input`\r\n * can be changed at any point in time.\r\n */\r\nvar Relay = /** @class */ (function () {\r\n    function Relay() {\r\n        var _this = this;\r\n        this.listening = false;\r\n        this.inputEvent = Event.None;\r\n        this.inputEventListener = Disposable.None;\r\n        this.emitter = new Emitter({\r\n            onFirstListenerDidAdd: function () {\r\n                _this.listening = true;\r\n                _this.inputEventListener = _this.inputEvent(_this.emitter.fire, _this.emitter);\r\n            },\r\n            onLastListenerRemove: function () {\r\n                _this.listening = false;\r\n                _this.inputEventListener.dispose();\r\n            }\r\n        });\r\n        this.event = this.emitter.event;\r\n    }\r\n    Object.defineProperty(Relay.prototype, \"input\", {\r\n        set: function (event) {\r\n            this.inputEvent = event;\r\n            if (this.listening) {\r\n                this.inputEventListener.dispose();\r\n                this.inputEventListener = event(this.emitter.fire, this.emitter);\r\n            }\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    Relay.prototype.dispose = function () {\r\n        this.inputEventListener.dispose();\r\n        this.emitter.dispose();\r\n    };\r\n    return Relay;\r\n}());\r\nexport { Relay };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { Emitter, Event } from './event.js';\r\nvar shortcutEvent = Object.freeze(function (callback, context) {\r\n    var handle = setTimeout(callback.bind(context), 0);\r\n    return { dispose: function () { clearTimeout(handle); } };\r\n});\r\nexport var CancellationToken;\r\n(function (CancellationToken) {\r\n    function isCancellationToken(thing) {\r\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\r\n            return true;\r\n        }\r\n        if (thing instanceof MutableToken) {\r\n            return true;\r\n        }\r\n        if (!thing || typeof thing !== 'object') {\r\n            return false;\r\n        }\r\n        return typeof thing.isCancellationRequested === 'boolean'\r\n            && typeof thing.onCancellationRequested === 'function';\r\n    }\r\n    CancellationToken.isCancellationToken = isCancellationToken;\r\n    CancellationToken.None = Object.freeze({\r\n        isCancellationRequested: false,\r\n        onCancellationRequested: Event.None\r\n    });\r\n    CancellationToken.Cancelled = Object.freeze({\r\n        isCancellationRequested: true,\r\n        onCancellationRequested: shortcutEvent\r\n    });\r\n})(CancellationToken || (CancellationToken = {}));\r\nvar MutableToken = /** @class */ (function () {\r\n    function MutableToken() {\r\n        this._isCancelled = false;\r\n        this._emitter = null;\r\n    }\r\n    MutableToken.prototype.cancel = function () {\r\n        if (!this._isCancelled) {\r\n            this._isCancelled = true;\r\n            if (this._emitter) {\r\n                this._emitter.fire(undefined);\r\n                this.dispose();\r\n            }\r\n        }\r\n    };\r\n    Object.defineProperty(MutableToken.prototype, \"isCancellationRequested\", {\r\n        get: function () {\r\n            return this._isCancelled;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(MutableToken.prototype, \"onCancellationRequested\", {\r\n        get: function () {\r\n            if (this._isCancelled) {\r\n                return shortcutEvent;\r\n            }\r\n            if (!this._emitter) {\r\n                this._emitter = new Emitter();\r\n            }\r\n            return this._emitter.event;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    MutableToken.prototype.dispose = function () {\r\n        if (this._emitter) {\r\n            this._emitter.dispose();\r\n            this._emitter = null;\r\n        }\r\n    };\r\n    return MutableToken;\r\n}());\r\nvar CancellationTokenSource = /** @class */ (function () {\r\n    function CancellationTokenSource(parent) {\r\n        this._token = undefined;\r\n        this._parentListener = undefined;\r\n        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\r\n    }\r\n    Object.defineProperty(CancellationTokenSource.prototype, \"token\", {\r\n        get: function () {\r\n            if (!this._token) {\r\n                // be lazy and create the token only when\r\n                // actually needed\r\n                this._token = new MutableToken();\r\n            }\r\n            return this._token;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    CancellationTokenSource.prototype.cancel = function () {\r\n        if (!this._token) {\r\n            // save an object by returning the default\r\n            // cancelled token when cancellation happens\r\n            // before someone asks for the token\r\n            this._token = CancellationToken.Cancelled;\r\n        }\r\n        else if (this._token instanceof MutableToken) {\r\n            // actually cancel\r\n            this._token.cancel();\r\n        }\r\n    };\r\n    CancellationTokenSource.prototype.dispose = function (cancel) {\r\n        if (cancel === void 0) { cancel = false; }\r\n        if (cancel) {\r\n            this.cancel();\r\n        }\r\n        if (this._parentListener) {\r\n            this._parentListener.dispose();\r\n        }\r\n        if (!this._token) {\r\n            // ensure to initialize with an empty token if we had none\r\n            this._token = CancellationToken.None;\r\n        }\r\n        else if (this._token instanceof MutableToken) {\r\n            // actually dispose\r\n            this._token.dispose();\r\n        }\r\n    };\r\n    return CancellationTokenSource;\r\n}());\r\nexport { CancellationTokenSource };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { illegalArgument } from './errors.js';\r\nvar KeyCodeStrMap = /** @class */ (function () {\r\n    function KeyCodeStrMap() {\r\n        this._keyCodeToStr = [];\r\n        this._strToKeyCode = Object.create(null);\r\n    }\r\n    KeyCodeStrMap.prototype.define = function (keyCode, str) {\r\n        this._keyCodeToStr[keyCode] = str;\r\n        this._strToKeyCode[str.toLowerCase()] = keyCode;\r\n    };\r\n    KeyCodeStrMap.prototype.keyCodeToStr = function (keyCode) {\r\n        return this._keyCodeToStr[keyCode];\r\n    };\r\n    KeyCodeStrMap.prototype.strToKeyCode = function (str) {\r\n        return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;\r\n    };\r\n    return KeyCodeStrMap;\r\n}());\r\nvar uiMap = new KeyCodeStrMap();\r\nvar userSettingsUSMap = new KeyCodeStrMap();\r\nvar userSettingsGeneralMap = new KeyCodeStrMap();\r\n(function () {\r\n    function define(keyCode, uiLabel, usUserSettingsLabel, generalUserSettingsLabel) {\r\n        if (usUserSettingsLabel === void 0) { usUserSettingsLabel = uiLabel; }\r\n        if (generalUserSettingsLabel === void 0) { generalUserSettingsLabel = usUserSettingsLabel; }\r\n        uiMap.define(keyCode, uiLabel);\r\n        userSettingsUSMap.define(keyCode, usUserSettingsLabel);\r\n        userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel);\r\n    }\r\n    define(0 /* Unknown */, 'unknown');\r\n    define(1 /* Backspace */, 'Backspace');\r\n    define(2 /* Tab */, 'Tab');\r\n    define(3 /* Enter */, 'Enter');\r\n    define(4 /* Shift */, 'Shift');\r\n    define(5 /* Ctrl */, 'Ctrl');\r\n    define(6 /* Alt */, 'Alt');\r\n    define(7 /* PauseBreak */, 'PauseBreak');\r\n    define(8 /* CapsLock */, 'CapsLock');\r\n    define(9 /* Escape */, 'Escape');\r\n    define(10 /* Space */, 'Space');\r\n    define(11 /* PageUp */, 'PageUp');\r\n    define(12 /* PageDown */, 'PageDown');\r\n    define(13 /* End */, 'End');\r\n    define(14 /* Home */, 'Home');\r\n    define(15 /* LeftArrow */, 'LeftArrow', 'Left');\r\n    define(16 /* UpArrow */, 'UpArrow', 'Up');\r\n    define(17 /* RightArrow */, 'RightArrow', 'Right');\r\n    define(18 /* DownArrow */, 'DownArrow', 'Down');\r\n    define(19 /* Insert */, 'Insert');\r\n    define(20 /* Delete */, 'Delete');\r\n    define(21 /* KEY_0 */, '0');\r\n    define(22 /* KEY_1 */, '1');\r\n    define(23 /* KEY_2 */, '2');\r\n    define(24 /* KEY_3 */, '3');\r\n    define(25 /* KEY_4 */, '4');\r\n    define(26 /* KEY_5 */, '5');\r\n    define(27 /* KEY_6 */, '6');\r\n    define(28 /* KEY_7 */, '7');\r\n    define(29 /* KEY_8 */, '8');\r\n    define(30 /* KEY_9 */, '9');\r\n    define(31 /* KEY_A */, 'A');\r\n    define(32 /* KEY_B */, 'B');\r\n    define(33 /* KEY_C */, 'C');\r\n    define(34 /* KEY_D */, 'D');\r\n    define(35 /* KEY_E */, 'E');\r\n    define(36 /* KEY_F */, 'F');\r\n    define(37 /* KEY_G */, 'G');\r\n    define(38 /* KEY_H */, 'H');\r\n    define(39 /* KEY_I */, 'I');\r\n    define(40 /* KEY_J */, 'J');\r\n    define(41 /* KEY_K */, 'K');\r\n    define(42 /* KEY_L */, 'L');\r\n    define(43 /* KEY_M */, 'M');\r\n    define(44 /* KEY_N */, 'N');\r\n    define(45 /* KEY_O */, 'O');\r\n    define(46 /* KEY_P */, 'P');\r\n    define(47 /* KEY_Q */, 'Q');\r\n    define(48 /* KEY_R */, 'R');\r\n    define(49 /* KEY_S */, 'S');\r\n    define(50 /* KEY_T */, 'T');\r\n    define(51 /* KEY_U */, 'U');\r\n    define(52 /* KEY_V */, 'V');\r\n    define(53 /* KEY_W */, 'W');\r\n    define(54 /* KEY_X */, 'X');\r\n    define(55 /* KEY_Y */, 'Y');\r\n    define(56 /* KEY_Z */, 'Z');\r\n    define(57 /* Meta */, 'Meta');\r\n    define(58 /* ContextMenu */, 'ContextMenu');\r\n    define(59 /* F1 */, 'F1');\r\n    define(60 /* F2 */, 'F2');\r\n    define(61 /* F3 */, 'F3');\r\n    define(62 /* F4 */, 'F4');\r\n    define(63 /* F5 */, 'F5');\r\n    define(64 /* F6 */, 'F6');\r\n    define(65 /* F7 */, 'F7');\r\n    define(66 /* F8 */, 'F8');\r\n    define(67 /* F9 */, 'F9');\r\n    define(68 /* F10 */, 'F10');\r\n    define(69 /* F11 */, 'F11');\r\n    define(70 /* F12 */, 'F12');\r\n    define(71 /* F13 */, 'F13');\r\n    define(72 /* F14 */, 'F14');\r\n    define(73 /* F15 */, 'F15');\r\n    define(74 /* F16 */, 'F16');\r\n    define(75 /* F17 */, 'F17');\r\n    define(76 /* F18 */, 'F18');\r\n    define(77 /* F19 */, 'F19');\r\n    define(78 /* NumLock */, 'NumLock');\r\n    define(79 /* ScrollLock */, 'ScrollLock');\r\n    define(80 /* US_SEMICOLON */, ';', ';', 'OEM_1');\r\n    define(81 /* US_EQUAL */, '=', '=', 'OEM_PLUS');\r\n    define(82 /* US_COMMA */, ',', ',', 'OEM_COMMA');\r\n    define(83 /* US_MINUS */, '-', '-', 'OEM_MINUS');\r\n    define(84 /* US_DOT */, '.', '.', 'OEM_PERIOD');\r\n    define(85 /* US_SLASH */, '/', '/', 'OEM_2');\r\n    define(86 /* US_BACKTICK */, '`', '`', 'OEM_3');\r\n    define(110 /* ABNT_C1 */, 'ABNT_C1');\r\n    define(111 /* ABNT_C2 */, 'ABNT_C2');\r\n    define(87 /* US_OPEN_SQUARE_BRACKET */, '[', '[', 'OEM_4');\r\n    define(88 /* US_BACKSLASH */, '\\\\', '\\\\', 'OEM_5');\r\n    define(89 /* US_CLOSE_SQUARE_BRACKET */, ']', ']', 'OEM_6');\r\n    define(90 /* US_QUOTE */, '\\'', '\\'', 'OEM_7');\r\n    define(91 /* OEM_8 */, 'OEM_8');\r\n    define(92 /* OEM_102 */, 'OEM_102');\r\n    define(93 /* NUMPAD_0 */, 'NumPad0');\r\n    define(94 /* NUMPAD_1 */, 'NumPad1');\r\n    define(95 /* NUMPAD_2 */, 'NumPad2');\r\n    define(96 /* NUMPAD_3 */, 'NumPad3');\r\n    define(97 /* NUMPAD_4 */, 'NumPad4');\r\n    define(98 /* NUMPAD_5 */, 'NumPad5');\r\n    define(99 /* NUMPAD_6 */, 'NumPad6');\r\n    define(100 /* NUMPAD_7 */, 'NumPad7');\r\n    define(101 /* NUMPAD_8 */, 'NumPad8');\r\n    define(102 /* NUMPAD_9 */, 'NumPad9');\r\n    define(103 /* NUMPAD_MULTIPLY */, 'NumPad_Multiply');\r\n    define(104 /* NUMPAD_ADD */, 'NumPad_Add');\r\n    define(105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator');\r\n    define(106 /* NUMPAD_SUBTRACT */, 'NumPad_Subtract');\r\n    define(107 /* NUMPAD_DECIMAL */, 'NumPad_Decimal');\r\n    define(108 /* NUMPAD_DIVIDE */, 'NumPad_Divide');\r\n})();\r\nexport var KeyCodeUtils;\r\n(function (KeyCodeUtils) {\r\n    function toString(keyCode) {\r\n        return uiMap.keyCodeToStr(keyCode);\r\n    }\r\n    KeyCodeUtils.toString = toString;\r\n    function fromString(key) {\r\n        return uiMap.strToKeyCode(key);\r\n    }\r\n    KeyCodeUtils.fromString = fromString;\r\n    function toUserSettingsUS(keyCode) {\r\n        return userSettingsUSMap.keyCodeToStr(keyCode);\r\n    }\r\n    KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\r\n    function toUserSettingsGeneral(keyCode) {\r\n        return userSettingsGeneralMap.keyCodeToStr(keyCode);\r\n    }\r\n    KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\r\n    function fromUserSettings(key) {\r\n        return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\r\n    }\r\n    KeyCodeUtils.fromUserSettings = fromUserSettings;\r\n})(KeyCodeUtils || (KeyCodeUtils = {}));\r\nexport function KeyChord(firstPart, secondPart) {\r\n    var chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\r\n    return (firstPart | chordPart) >>> 0;\r\n}\r\nexport function createKeybinding(keybinding, OS) {\r\n    if (keybinding === 0) {\r\n        return null;\r\n    }\r\n    var firstPart = (keybinding & 0x0000FFFF) >>> 0;\r\n    var chordPart = (keybinding & 0xFFFF0000) >>> 16;\r\n    if (chordPart !== 0) {\r\n        return new ChordKeybinding([\r\n            createSimpleKeybinding(firstPart, OS),\r\n            createSimpleKeybinding(chordPart, OS)\r\n        ]);\r\n    }\r\n    return new ChordKeybinding([createSimpleKeybinding(firstPart, OS)]);\r\n}\r\nexport function createSimpleKeybinding(keybinding, OS) {\r\n    var ctrlCmd = (keybinding & 2048 /* CtrlCmd */ ? true : false);\r\n    var winCtrl = (keybinding & 256 /* WinCtrl */ ? true : false);\r\n    var ctrlKey = (OS === 2 /* Macintosh */ ? winCtrl : ctrlCmd);\r\n    var shiftKey = (keybinding & 1024 /* Shift */ ? true : false);\r\n    var altKey = (keybinding & 512 /* Alt */ ? true : false);\r\n    var metaKey = (OS === 2 /* Macintosh */ ? ctrlCmd : winCtrl);\r\n    var keyCode = (keybinding & 255 /* KeyCode */);\r\n    return new SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode);\r\n}\r\nvar SimpleKeybinding = /** @class */ (function () {\r\n    function SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode) {\r\n        this.ctrlKey = ctrlKey;\r\n        this.shiftKey = shiftKey;\r\n        this.altKey = altKey;\r\n        this.metaKey = metaKey;\r\n        this.keyCode = keyCode;\r\n    }\r\n    SimpleKeybinding.prototype.equals = function (other) {\r\n        return (this.ctrlKey === other.ctrlKey\r\n            && this.shiftKey === other.shiftKey\r\n            && this.altKey === other.altKey\r\n            && this.metaKey === other.metaKey\r\n            && this.keyCode === other.keyCode);\r\n    };\r\n    SimpleKeybinding.prototype.isModifierKey = function () {\r\n        return (this.keyCode === 0 /* Unknown */\r\n            || this.keyCode === 5 /* Ctrl */\r\n            || this.keyCode === 57 /* Meta */\r\n            || this.keyCode === 6 /* Alt */\r\n            || this.keyCode === 4 /* Shift */);\r\n    };\r\n    SimpleKeybinding.prototype.toChord = function () {\r\n        return new ChordKeybinding([this]);\r\n    };\r\n    /**\r\n     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?\r\n     */\r\n    SimpleKeybinding.prototype.isDuplicateModifierCase = function () {\r\n        return ((this.ctrlKey && this.keyCode === 5 /* Ctrl */)\r\n            || (this.shiftKey && this.keyCode === 4 /* Shift */)\r\n            || (this.altKey && this.keyCode === 6 /* Alt */)\r\n            || (this.metaKey && this.keyCode === 57 /* Meta */));\r\n    };\r\n    return SimpleKeybinding;\r\n}());\r\nexport { SimpleKeybinding };\r\nvar ChordKeybinding = /** @class */ (function () {\r\n    function ChordKeybinding(parts) {\r\n        if (parts.length === 0) {\r\n            throw illegalArgument(\"parts\");\r\n        }\r\n        this.parts = parts;\r\n    }\r\n    ChordKeybinding.prototype.equals = function (other) {\r\n        if (other === null) {\r\n            return false;\r\n        }\r\n        if (this.parts.length !== other.parts.length) {\r\n            return false;\r\n        }\r\n        for (var i = 0; i < this.parts.length; i++) {\r\n            if (!this.parts[i].equals(other.parts[i])) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    };\r\n    return ChordKeybinding;\r\n}());\r\nexport { ChordKeybinding };\r\nvar ResolvedKeybindingPart = /** @class */ (function () {\r\n    function ResolvedKeybindingPart(ctrlKey, shiftKey, altKey, metaKey, kbLabel, kbAriaLabel) {\r\n        this.ctrlKey = ctrlKey;\r\n        this.shiftKey = shiftKey;\r\n        this.altKey = altKey;\r\n        this.metaKey = metaKey;\r\n        this.keyLabel = kbLabel;\r\n        this.keyAriaLabel = kbAriaLabel;\r\n    }\r\n    return ResolvedKeybindingPart;\r\n}());\r\nexport { ResolvedKeybindingPart };\r\n/**\r\n * A resolved keybinding. Can be a simple keybinding or a chord keybinding.\r\n */\r\nvar ResolvedKeybinding = /** @class */ (function () {\r\n    function ResolvedKeybinding() {\r\n    }\r\n    return ResolvedKeybinding;\r\n}());\r\nexport { ResolvedKeybinding };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\r\nexport var AccessibilitySupport;\r\n(function (AccessibilitySupport) {\r\n    /**\r\n     * This should be the browser case where it is not known if a screen reader is attached or no.\r\n     */\r\n    AccessibilitySupport[AccessibilitySupport[\"Unknown\"] = 0] = \"Unknown\";\r\n    AccessibilitySupport[AccessibilitySupport[\"Disabled\"] = 1] = \"Disabled\";\r\n    AccessibilitySupport[AccessibilitySupport[\"Enabled\"] = 2] = \"Enabled\";\r\n})(AccessibilitySupport || (AccessibilitySupport = {}));\r\nexport var CompletionItemInsertTextRule;\r\n(function (CompletionItemInsertTextRule) {\r\n    /**\r\n     * Adjust whitespace/indentation of multiline insert texts to\r\n     * match the current line indentation.\r\n     */\r\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\r\n    /**\r\n     * `insertText` is a snippet.\r\n     */\r\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\r\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\r\nexport var CompletionItemKind;\r\n(function (CompletionItemKind) {\r\n    CompletionItemKind[CompletionItemKind[\"Method\"] = 0] = \"Method\";\r\n    CompletionItemKind[CompletionItemKind[\"Function\"] = 1] = \"Function\";\r\n    CompletionItemKind[CompletionItemKind[\"Constructor\"] = 2] = \"Constructor\";\r\n    CompletionItemKind[CompletionItemKind[\"Field\"] = 3] = \"Field\";\r\n    CompletionItemKind[CompletionItemKind[\"Variable\"] = 4] = \"Variable\";\r\n    CompletionItemKind[CompletionItemKind[\"Class\"] = 5] = \"Class\";\r\n    CompletionItemKind[CompletionItemKind[\"Struct\"] = 6] = \"Struct\";\r\n    CompletionItemKind[CompletionItemKind[\"Interface\"] = 7] = \"Interface\";\r\n    CompletionItemKind[CompletionItemKind[\"Module\"] = 8] = \"Module\";\r\n    CompletionItemKind[CompletionItemKind[\"Property\"] = 9] = \"Property\";\r\n    CompletionItemKind[CompletionItemKind[\"Event\"] = 10] = \"Event\";\r\n    CompletionItemKind[CompletionItemKind[\"Operator\"] = 11] = \"Operator\";\r\n    CompletionItemKind[CompletionItemKind[\"Unit\"] = 12] = \"Unit\";\r\n    CompletionItemKind[CompletionItemKind[\"Value\"] = 13] = \"Value\";\r\n    CompletionItemKind[CompletionItemKind[\"Constant\"] = 14] = \"Constant\";\r\n    CompletionItemKind[CompletionItemKind[\"Enum\"] = 15] = \"Enum\";\r\n    CompletionItemKind[CompletionItemKind[\"EnumMember\"] = 16] = \"EnumMember\";\r\n    CompletionItemKind[CompletionItemKind[\"Keyword\"] = 17] = \"Keyword\";\r\n    CompletionItemKind[CompletionItemKind[\"Text\"] = 18] = \"Text\";\r\n    CompletionItemKind[CompletionItemKind[\"Color\"] = 19] = \"Color\";\r\n    CompletionItemKind[CompletionItemKind[\"File\"] = 20] = \"File\";\r\n    CompletionItemKind[CompletionItemKind[\"Reference\"] = 21] = \"Reference\";\r\n    CompletionItemKind[CompletionItemKind[\"Customcolor\"] = 22] = \"Customcolor\";\r\n    CompletionItemKind[CompletionItemKind[\"Folder\"] = 23] = \"Folder\";\r\n    CompletionItemKind[CompletionItemKind[\"TypeParameter\"] = 24] = \"TypeParameter\";\r\n    CompletionItemKind[CompletionItemKind[\"Snippet\"] = 25] = \"Snippet\";\r\n})(CompletionItemKind || (CompletionItemKind = {}));\r\nexport var CompletionItemTag;\r\n(function (CompletionItemTag) {\r\n    CompletionItemTag[CompletionItemTag[\"Deprecated\"] = 1] = \"Deprecated\";\r\n})(CompletionItemTag || (CompletionItemTag = {}));\r\n/**\r\n * How a suggest provider was triggered.\r\n */\r\nexport var CompletionTriggerKind;\r\n(function (CompletionTriggerKind) {\r\n    CompletionTriggerKind[CompletionTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\r\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerCharacter\"] = 1] = \"TriggerCharacter\";\r\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerForIncompleteCompletions\"] = 2] = \"TriggerForIncompleteCompletions\";\r\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\r\n/**\r\n * A positioning preference for rendering content widgets.\r\n */\r\nexport var ContentWidgetPositionPreference;\r\n(function (ContentWidgetPositionPreference) {\r\n    /**\r\n     * Place the content widget exactly at a position\r\n     */\r\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"EXACT\"] = 0] = \"EXACT\";\r\n    /**\r\n     * Place the content widget above a position\r\n     */\r\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"ABOVE\"] = 1] = \"ABOVE\";\r\n    /**\r\n     * Place the content widget below a position\r\n     */\r\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"BELOW\"] = 2] = \"BELOW\";\r\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\r\n/**\r\n * Describes the reason the cursor has changed its position.\r\n */\r\nexport var CursorChangeReason;\r\n(function (CursorChangeReason) {\r\n    /**\r\n     * Unknown or not set.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"NotSet\"] = 0] = \"NotSet\";\r\n    /**\r\n     * A `model.setValue()` was called.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"ContentFlush\"] = 1] = \"ContentFlush\";\r\n    /**\r\n     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"RecoverFromMarkers\"] = 2] = \"RecoverFromMarkers\";\r\n    /**\r\n     * There was an explicit user gesture.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"Explicit\"] = 3] = \"Explicit\";\r\n    /**\r\n     * There was a Paste.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"Paste\"] = 4] = \"Paste\";\r\n    /**\r\n     * There was an Undo.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"Undo\"] = 5] = \"Undo\";\r\n    /**\r\n     * There was a Redo.\r\n     */\r\n    CursorChangeReason[CursorChangeReason[\"Redo\"] = 6] = \"Redo\";\r\n})(CursorChangeReason || (CursorChangeReason = {}));\r\n/**\r\n * The default end of line to use when instantiating models.\r\n */\r\nexport var DefaultEndOfLine;\r\n(function (DefaultEndOfLine) {\r\n    /**\r\n     * Use line feed (\\n) as the end of line character.\r\n     */\r\n    DefaultEndOfLine[DefaultEndOfLine[\"LF\"] = 1] = \"LF\";\r\n    /**\r\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\r\n     */\r\n    DefaultEndOfLine[DefaultEndOfLine[\"CRLF\"] = 2] = \"CRLF\";\r\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\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[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\r\n    /**\r\n     * Read-access of a symbol, like reading a variable.\r\n     */\r\n    DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\r\n    /**\r\n     * Write-access of a symbol, like writing to a variable.\r\n     */\r\n    DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\r\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\r\n/**\r\n * Configuration options for auto indentation in the editor\r\n */\r\nexport var EditorAutoIndentStrategy;\r\n(function (EditorAutoIndentStrategy) {\r\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"None\"] = 0] = \"None\";\r\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Keep\"] = 1] = \"Keep\";\r\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Brackets\"] = 2] = \"Brackets\";\r\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Advanced\"] = 3] = \"Advanced\";\r\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Full\"] = 4] = \"Full\";\r\n})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {}));\r\nexport var EditorOption;\r\n(function (EditorOption) {\r\n    EditorOption[EditorOption[\"acceptSuggestionOnCommitCharacter\"] = 0] = \"acceptSuggestionOnCommitCharacter\";\r\n    EditorOption[EditorOption[\"acceptSuggestionOnEnter\"] = 1] = \"acceptSuggestionOnEnter\";\r\n    EditorOption[EditorOption[\"accessibilitySupport\"] = 2] = \"accessibilitySupport\";\r\n    EditorOption[EditorOption[\"accessibilityPageSize\"] = 3] = \"accessibilityPageSize\";\r\n    EditorOption[EditorOption[\"ariaLabel\"] = 4] = \"ariaLabel\";\r\n    EditorOption[EditorOption[\"autoClosingBrackets\"] = 5] = \"autoClosingBrackets\";\r\n    EditorOption[EditorOption[\"autoClosingOvertype\"] = 6] = \"autoClosingOvertype\";\r\n    EditorOption[EditorOption[\"autoClosingQuotes\"] = 7] = \"autoClosingQuotes\";\r\n    EditorOption[EditorOption[\"autoIndent\"] = 8] = \"autoIndent\";\r\n    EditorOption[EditorOption[\"automaticLayout\"] = 9] = \"automaticLayout\";\r\n    EditorOption[EditorOption[\"autoSurround\"] = 10] = \"autoSurround\";\r\n    EditorOption[EditorOption[\"codeLens\"] = 11] = \"codeLens\";\r\n    EditorOption[EditorOption[\"colorDecorators\"] = 12] = \"colorDecorators\";\r\n    EditorOption[EditorOption[\"comments\"] = 13] = \"comments\";\r\n    EditorOption[EditorOption[\"contextmenu\"] = 14] = \"contextmenu\";\r\n    EditorOption[EditorOption[\"copyWithSyntaxHighlighting\"] = 15] = \"copyWithSyntaxHighlighting\";\r\n    EditorOption[EditorOption[\"cursorBlinking\"] = 16] = \"cursorBlinking\";\r\n    EditorOption[EditorOption[\"cursorSmoothCaretAnimation\"] = 17] = \"cursorSmoothCaretAnimation\";\r\n    EditorOption[EditorOption[\"cursorStyle\"] = 18] = \"cursorStyle\";\r\n    EditorOption[EditorOption[\"cursorSurroundingLines\"] = 19] = \"cursorSurroundingLines\";\r\n    EditorOption[EditorOption[\"cursorSurroundingLinesStyle\"] = 20] = \"cursorSurroundingLinesStyle\";\r\n    EditorOption[EditorOption[\"cursorWidth\"] = 21] = \"cursorWidth\";\r\n    EditorOption[EditorOption[\"disableLayerHinting\"] = 22] = \"disableLayerHinting\";\r\n    EditorOption[EditorOption[\"disableMonospaceOptimizations\"] = 23] = \"disableMonospaceOptimizations\";\r\n    EditorOption[EditorOption[\"dragAndDrop\"] = 24] = \"dragAndDrop\";\r\n    EditorOption[EditorOption[\"emptySelectionClipboard\"] = 25] = \"emptySelectionClipboard\";\r\n    EditorOption[EditorOption[\"extraEditorClassName\"] = 26] = \"extraEditorClassName\";\r\n    EditorOption[EditorOption[\"fastScrollSensitivity\"] = 27] = \"fastScrollSensitivity\";\r\n    EditorOption[EditorOption[\"find\"] = 28] = \"find\";\r\n    EditorOption[EditorOption[\"fixedOverflowWidgets\"] = 29] = \"fixedOverflowWidgets\";\r\n    EditorOption[EditorOption[\"folding\"] = 30] = \"folding\";\r\n    EditorOption[EditorOption[\"foldingStrategy\"] = 31] = \"foldingStrategy\";\r\n    EditorOption[EditorOption[\"foldingHighlight\"] = 32] = \"foldingHighlight\";\r\n    EditorOption[EditorOption[\"fontFamily\"] = 33] = \"fontFamily\";\r\n    EditorOption[EditorOption[\"fontInfo\"] = 34] = \"fontInfo\";\r\n    EditorOption[EditorOption[\"fontLigatures\"] = 35] = \"fontLigatures\";\r\n    EditorOption[EditorOption[\"fontSize\"] = 36] = \"fontSize\";\r\n    EditorOption[EditorOption[\"fontWeight\"] = 37] = \"fontWeight\";\r\n    EditorOption[EditorOption[\"formatOnPaste\"] = 38] = \"formatOnPaste\";\r\n    EditorOption[EditorOption[\"formatOnType\"] = 39] = \"formatOnType\";\r\n    EditorOption[EditorOption[\"glyphMargin\"] = 40] = \"glyphMargin\";\r\n    EditorOption[EditorOption[\"gotoLocation\"] = 41] = \"gotoLocation\";\r\n    EditorOption[EditorOption[\"hideCursorInOverviewRuler\"] = 42] = \"hideCursorInOverviewRuler\";\r\n    EditorOption[EditorOption[\"highlightActiveIndentGuide\"] = 43] = \"highlightActiveIndentGuide\";\r\n    EditorOption[EditorOption[\"hover\"] = 44] = \"hover\";\r\n    EditorOption[EditorOption[\"inDiffEditor\"] = 45] = \"inDiffEditor\";\r\n    EditorOption[EditorOption[\"letterSpacing\"] = 46] = \"letterSpacing\";\r\n    EditorOption[EditorOption[\"lightbulb\"] = 47] = \"lightbulb\";\r\n    EditorOption[EditorOption[\"lineDecorationsWidth\"] = 48] = \"lineDecorationsWidth\";\r\n    EditorOption[EditorOption[\"lineHeight\"] = 49] = \"lineHeight\";\r\n    EditorOption[EditorOption[\"lineNumbers\"] = 50] = \"lineNumbers\";\r\n    EditorOption[EditorOption[\"lineNumbersMinChars\"] = 51] = \"lineNumbersMinChars\";\r\n    EditorOption[EditorOption[\"links\"] = 52] = \"links\";\r\n    EditorOption[EditorOption[\"matchBrackets\"] = 53] = \"matchBrackets\";\r\n    EditorOption[EditorOption[\"minimap\"] = 54] = \"minimap\";\r\n    EditorOption[EditorOption[\"mouseStyle\"] = 55] = \"mouseStyle\";\r\n    EditorOption[EditorOption[\"mouseWheelScrollSensitivity\"] = 56] = \"mouseWheelScrollSensitivity\";\r\n    EditorOption[EditorOption[\"mouseWheelZoom\"] = 57] = \"mouseWheelZoom\";\r\n    EditorOption[EditorOption[\"multiCursorMergeOverlapping\"] = 58] = \"multiCursorMergeOverlapping\";\r\n    EditorOption[EditorOption[\"multiCursorModifier\"] = 59] = \"multiCursorModifier\";\r\n    EditorOption[EditorOption[\"multiCursorPaste\"] = 60] = \"multiCursorPaste\";\r\n    EditorOption[EditorOption[\"occurrencesHighlight\"] = 61] = \"occurrencesHighlight\";\r\n    EditorOption[EditorOption[\"overviewRulerBorder\"] = 62] = \"overviewRulerBorder\";\r\n    EditorOption[EditorOption[\"overviewRulerLanes\"] = 63] = \"overviewRulerLanes\";\r\n    EditorOption[EditorOption[\"parameterHints\"] = 64] = \"parameterHints\";\r\n    EditorOption[EditorOption[\"peekWidgetDefaultFocus\"] = 65] = \"peekWidgetDefaultFocus\";\r\n    EditorOption[EditorOption[\"quickSuggestions\"] = 66] = \"quickSuggestions\";\r\n    EditorOption[EditorOption[\"quickSuggestionsDelay\"] = 67] = \"quickSuggestionsDelay\";\r\n    EditorOption[EditorOption[\"readOnly\"] = 68] = \"readOnly\";\r\n    EditorOption[EditorOption[\"renderControlCharacters\"] = 69] = \"renderControlCharacters\";\r\n    EditorOption[EditorOption[\"renderIndentGuides\"] = 70] = \"renderIndentGuides\";\r\n    EditorOption[EditorOption[\"renderFinalNewline\"] = 71] = \"renderFinalNewline\";\r\n    EditorOption[EditorOption[\"renderLineHighlight\"] = 72] = \"renderLineHighlight\";\r\n    EditorOption[EditorOption[\"renderValidationDecorations\"] = 73] = \"renderValidationDecorations\";\r\n    EditorOption[EditorOption[\"renderWhitespace\"] = 74] = \"renderWhitespace\";\r\n    EditorOption[EditorOption[\"revealHorizontalRightPadding\"] = 75] = \"revealHorizontalRightPadding\";\r\n    EditorOption[EditorOption[\"roundedSelection\"] = 76] = \"roundedSelection\";\r\n    EditorOption[EditorOption[\"rulers\"] = 77] = \"rulers\";\r\n    EditorOption[EditorOption[\"scrollbar\"] = 78] = \"scrollbar\";\r\n    EditorOption[EditorOption[\"scrollBeyondLastColumn\"] = 79] = \"scrollBeyondLastColumn\";\r\n    EditorOption[EditorOption[\"scrollBeyondLastLine\"] = 80] = \"scrollBeyondLastLine\";\r\n    EditorOption[EditorOption[\"selectionClipboard\"] = 81] = \"selectionClipboard\";\r\n    EditorOption[EditorOption[\"selectionHighlight\"] = 82] = \"selectionHighlight\";\r\n    EditorOption[EditorOption[\"selectOnLineNumbers\"] = 83] = \"selectOnLineNumbers\";\r\n    EditorOption[EditorOption[\"showFoldingControls\"] = 84] = \"showFoldingControls\";\r\n    EditorOption[EditorOption[\"showUnused\"] = 85] = \"showUnused\";\r\n    EditorOption[EditorOption[\"snippetSuggestions\"] = 86] = \"snippetSuggestions\";\r\n    EditorOption[EditorOption[\"smoothScrolling\"] = 87] = \"smoothScrolling\";\r\n    EditorOption[EditorOption[\"stopRenderingLineAfter\"] = 88] = \"stopRenderingLineAfter\";\r\n    EditorOption[EditorOption[\"suggest\"] = 89] = \"suggest\";\r\n    EditorOption[EditorOption[\"suggestFontSize\"] = 90] = \"suggestFontSize\";\r\n    EditorOption[EditorOption[\"suggestLineHeight\"] = 91] = \"suggestLineHeight\";\r\n    EditorOption[EditorOption[\"suggestOnTriggerCharacters\"] = 92] = \"suggestOnTriggerCharacters\";\r\n    EditorOption[EditorOption[\"suggestSelection\"] = 93] = \"suggestSelection\";\r\n    EditorOption[EditorOption[\"tabCompletion\"] = 94] = \"tabCompletion\";\r\n    EditorOption[EditorOption[\"useTabStops\"] = 95] = \"useTabStops\";\r\n    EditorOption[EditorOption[\"wordSeparators\"] = 96] = \"wordSeparators\";\r\n    EditorOption[EditorOption[\"wordWrap\"] = 97] = \"wordWrap\";\r\n    EditorOption[EditorOption[\"wordWrapBreakAfterCharacters\"] = 98] = \"wordWrapBreakAfterCharacters\";\r\n    EditorOption[EditorOption[\"wordWrapBreakBeforeCharacters\"] = 99] = \"wordWrapBreakBeforeCharacters\";\r\n    EditorOption[EditorOption[\"wordWrapColumn\"] = 100] = \"wordWrapColumn\";\r\n    EditorOption[EditorOption[\"wordWrapMinified\"] = 101] = \"wordWrapMinified\";\r\n    EditorOption[EditorOption[\"wrappingIndent\"] = 102] = \"wrappingIndent\";\r\n    EditorOption[EditorOption[\"wrappingStrategy\"] = 103] = \"wrappingStrategy\";\r\n    EditorOption[EditorOption[\"editorClassName\"] = 104] = \"editorClassName\";\r\n    EditorOption[EditorOption[\"pixelRatio\"] = 105] = \"pixelRatio\";\r\n    EditorOption[EditorOption[\"tabFocusMode\"] = 106] = \"tabFocusMode\";\r\n    EditorOption[EditorOption[\"layoutInfo\"] = 107] = \"layoutInfo\";\r\n    EditorOption[EditorOption[\"wrappingInfo\"] = 108] = \"wrappingInfo\";\r\n})(EditorOption || (EditorOption = {}));\r\n/**\r\n * End of line character preference.\r\n */\r\nexport var EndOfLinePreference;\r\n(function (EndOfLinePreference) {\r\n    /**\r\n     * Use the end of line character identified in the text buffer.\r\n     */\r\n    EndOfLinePreference[EndOfLinePreference[\"TextDefined\"] = 0] = \"TextDefined\";\r\n    /**\r\n     * Use line feed (\\n) as the end of line character.\r\n     */\r\n    EndOfLinePreference[EndOfLinePreference[\"LF\"] = 1] = \"LF\";\r\n    /**\r\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\r\n     */\r\n    EndOfLinePreference[EndOfLinePreference[\"CRLF\"] = 2] = \"CRLF\";\r\n})(EndOfLinePreference || (EndOfLinePreference = {}));\r\n/**\r\n * End of line character preference.\r\n */\r\nexport var EndOfLineSequence;\r\n(function (EndOfLineSequence) {\r\n    /**\r\n     * Use line feed (\\n) as the end of line character.\r\n     */\r\n    EndOfLineSequence[EndOfLineSequence[\"LF\"] = 0] = \"LF\";\r\n    /**\r\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\r\n     */\r\n    EndOfLineSequence[EndOfLineSequence[\"CRLF\"] = 1] = \"CRLF\";\r\n})(EndOfLineSequence || (EndOfLineSequence = {}));\r\n/**\r\n * Describes what to do with the indentation when pressing Enter.\r\n */\r\nexport var IndentAction;\r\n(function (IndentAction) {\r\n    /**\r\n     * Insert new line and copy the previous line's indentation.\r\n     */\r\n    IndentAction[IndentAction[\"None\"] = 0] = \"None\";\r\n    /**\r\n     * Insert new line and indent once (relative to the previous line's indentation).\r\n     */\r\n    IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\r\n    /**\r\n     * Insert two new lines:\r\n     *  - the first one indented which will hold the cursor\r\n     *  - the second one at the same indentation level\r\n     */\r\n    IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\r\n    /**\r\n     * Insert new line and outdent once (relative to the previous line's indentation).\r\n     */\r\n    IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\r\n})(IndentAction || (IndentAction = {}));\r\n/**\r\n * Virtual Key Codes, the value does not hold any inherent meaning.\r\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\r\n * But these are \"more general\", as they should work across browsers & OS`s.\r\n */\r\nexport var KeyCode;\r\n(function (KeyCode) {\r\n    /**\r\n     * Placed first to cover the 0 value of the enum.\r\n     */\r\n    KeyCode[KeyCode[\"Unknown\"] = 0] = \"Unknown\";\r\n    KeyCode[KeyCode[\"Backspace\"] = 1] = \"Backspace\";\r\n    KeyCode[KeyCode[\"Tab\"] = 2] = \"Tab\";\r\n    KeyCode[KeyCode[\"Enter\"] = 3] = \"Enter\";\r\n    KeyCode[KeyCode[\"Shift\"] = 4] = \"Shift\";\r\n    KeyCode[KeyCode[\"Ctrl\"] = 5] = \"Ctrl\";\r\n    KeyCode[KeyCode[\"Alt\"] = 6] = \"Alt\";\r\n    KeyCode[KeyCode[\"PauseBreak\"] = 7] = \"PauseBreak\";\r\n    KeyCode[KeyCode[\"CapsLock\"] = 8] = \"CapsLock\";\r\n    KeyCode[KeyCode[\"Escape\"] = 9] = \"Escape\";\r\n    KeyCode[KeyCode[\"Space\"] = 10] = \"Space\";\r\n    KeyCode[KeyCode[\"PageUp\"] = 11] = \"PageUp\";\r\n    KeyCode[KeyCode[\"PageDown\"] = 12] = \"PageDown\";\r\n    KeyCode[KeyCode[\"End\"] = 13] = \"End\";\r\n    KeyCode[KeyCode[\"Home\"] = 14] = \"Home\";\r\n    KeyCode[KeyCode[\"LeftArrow\"] = 15] = \"LeftArrow\";\r\n    KeyCode[KeyCode[\"UpArrow\"] = 16] = \"UpArrow\";\r\n    KeyCode[KeyCode[\"RightArrow\"] = 17] = \"RightArrow\";\r\n    KeyCode[KeyCode[\"DownArrow\"] = 18] = \"DownArrow\";\r\n    KeyCode[KeyCode[\"Insert\"] = 19] = \"Insert\";\r\n    KeyCode[KeyCode[\"Delete\"] = 20] = \"Delete\";\r\n    KeyCode[KeyCode[\"KEY_0\"] = 21] = \"KEY_0\";\r\n    KeyCode[KeyCode[\"KEY_1\"] = 22] = \"KEY_1\";\r\n    KeyCode[KeyCode[\"KEY_2\"] = 23] = \"KEY_2\";\r\n    KeyCode[KeyCode[\"KEY_3\"] = 24] = \"KEY_3\";\r\n    KeyCode[KeyCode[\"KEY_4\"] = 25] = \"KEY_4\";\r\n    KeyCode[KeyCode[\"KEY_5\"] = 26] = \"KEY_5\";\r\n    KeyCode[KeyCode[\"KEY_6\"] = 27] = \"KEY_6\";\r\n    KeyCode[KeyCode[\"KEY_7\"] = 28] = \"KEY_7\";\r\n    KeyCode[KeyCode[\"KEY_8\"] = 29] = \"KEY_8\";\r\n    KeyCode[KeyCode[\"KEY_9\"] = 30] = \"KEY_9\";\r\n    KeyCode[KeyCode[\"KEY_A\"] = 31] = \"KEY_A\";\r\n    KeyCode[KeyCode[\"KEY_B\"] = 32] = \"KEY_B\";\r\n    KeyCode[KeyCode[\"KEY_C\"] = 33] = \"KEY_C\";\r\n    KeyCode[KeyCode[\"KEY_D\"] = 34] = \"KEY_D\";\r\n    KeyCode[KeyCode[\"KEY_E\"] = 35] = \"KEY_E\";\r\n    KeyCode[KeyCode[\"KEY_F\"] = 36] = \"KEY_F\";\r\n    KeyCode[KeyCode[\"KEY_G\"] = 37] = \"KEY_G\";\r\n    KeyCode[KeyCode[\"KEY_H\"] = 38] = \"KEY_H\";\r\n    KeyCode[KeyCode[\"KEY_I\"] = 39] = \"KEY_I\";\r\n    KeyCode[KeyCode[\"KEY_J\"] = 40] = \"KEY_J\";\r\n    KeyCode[KeyCode[\"KEY_K\"] = 41] = \"KEY_K\";\r\n    KeyCode[KeyCode[\"KEY_L\"] = 42] = \"KEY_L\";\r\n    KeyCode[KeyCode[\"KEY_M\"] = 43] = \"KEY_M\";\r\n    KeyCode[KeyCode[\"KEY_N\"] = 44] = \"KEY_N\";\r\n    KeyCode[KeyCode[\"KEY_O\"] = 45] = \"KEY_O\";\r\n    KeyCode[KeyCode[\"KEY_P\"] = 46] = \"KEY_P\";\r\n    KeyCode[KeyCode[\"KEY_Q\"] = 47] = \"KEY_Q\";\r\n    KeyCode[KeyCode[\"KEY_R\"] = 48] = \"KEY_R\";\r\n    KeyCode[KeyCode[\"KEY_S\"] = 49] = \"KEY_S\";\r\n    KeyCode[KeyCode[\"KEY_T\"] = 50] = \"KEY_T\";\r\n    KeyCode[KeyCode[\"KEY_U\"] = 51] = \"KEY_U\";\r\n    KeyCode[KeyCode[\"KEY_V\"] = 52] = \"KEY_V\";\r\n    KeyCode[KeyCode[\"KEY_W\"] = 53] = \"KEY_W\";\r\n    KeyCode[KeyCode[\"KEY_X\"] = 54] = \"KEY_X\";\r\n    KeyCode[KeyCode[\"KEY_Y\"] = 55] = \"KEY_Y\";\r\n    KeyCode[KeyCode[\"KEY_Z\"] = 56] = \"KEY_Z\";\r\n    KeyCode[KeyCode[\"Meta\"] = 57] = \"Meta\";\r\n    KeyCode[KeyCode[\"ContextMenu\"] = 58] = \"ContextMenu\";\r\n    KeyCode[KeyCode[\"F1\"] = 59] = \"F1\";\r\n    KeyCode[KeyCode[\"F2\"] = 60] = \"F2\";\r\n    KeyCode[KeyCode[\"F3\"] = 61] = \"F3\";\r\n    KeyCode[KeyCode[\"F4\"] = 62] = \"F4\";\r\n    KeyCode[KeyCode[\"F5\"] = 63] = \"F5\";\r\n    KeyCode[KeyCode[\"F6\"] = 64] = \"F6\";\r\n    KeyCode[KeyCode[\"F7\"] = 65] = \"F7\";\r\n    KeyCode[KeyCode[\"F8\"] = 66] = \"F8\";\r\n    KeyCode[KeyCode[\"F9\"] = 67] = \"F9\";\r\n    KeyCode[KeyCode[\"F10\"] = 68] = \"F10\";\r\n    KeyCode[KeyCode[\"F11\"] = 69] = \"F11\";\r\n    KeyCode[KeyCode[\"F12\"] = 70] = \"F12\";\r\n    KeyCode[KeyCode[\"F13\"] = 71] = \"F13\";\r\n    KeyCode[KeyCode[\"F14\"] = 72] = \"F14\";\r\n    KeyCode[KeyCode[\"F15\"] = 73] = \"F15\";\r\n    KeyCode[KeyCode[\"F16\"] = 74] = \"F16\";\r\n    KeyCode[KeyCode[\"F17\"] = 75] = \"F17\";\r\n    KeyCode[KeyCode[\"F18\"] = 76] = \"F18\";\r\n    KeyCode[KeyCode[\"F19\"] = 77] = \"F19\";\r\n    KeyCode[KeyCode[\"NumLock\"] = 78] = \"NumLock\";\r\n    KeyCode[KeyCode[\"ScrollLock\"] = 79] = \"ScrollLock\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the ';:' key\r\n     */\r\n    KeyCode[KeyCode[\"US_SEMICOLON\"] = 80] = \"US_SEMICOLON\";\r\n    /**\r\n     * For any country/region, the '+' key\r\n     * For the US standard keyboard, the '=+' key\r\n     */\r\n    KeyCode[KeyCode[\"US_EQUAL\"] = 81] = \"US_EQUAL\";\r\n    /**\r\n     * For any country/region, the ',' key\r\n     * For the US standard keyboard, the ',<' key\r\n     */\r\n    KeyCode[KeyCode[\"US_COMMA\"] = 82] = \"US_COMMA\";\r\n    /**\r\n     * For any country/region, the '-' key\r\n     * For the US standard keyboard, the '-_' key\r\n     */\r\n    KeyCode[KeyCode[\"US_MINUS\"] = 83] = \"US_MINUS\";\r\n    /**\r\n     * For any country/region, the '.' key\r\n     * For the US standard keyboard, the '.>' key\r\n     */\r\n    KeyCode[KeyCode[\"US_DOT\"] = 84] = \"US_DOT\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the '/?' key\r\n     */\r\n    KeyCode[KeyCode[\"US_SLASH\"] = 85] = \"US_SLASH\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the '`~' key\r\n     */\r\n    KeyCode[KeyCode[\"US_BACKTICK\"] = 86] = \"US_BACKTICK\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the '[{' key\r\n     */\r\n    KeyCode[KeyCode[\"US_OPEN_SQUARE_BRACKET\"] = 87] = \"US_OPEN_SQUARE_BRACKET\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the '\\|' key\r\n     */\r\n    KeyCode[KeyCode[\"US_BACKSLASH\"] = 88] = \"US_BACKSLASH\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the ']}' key\r\n     */\r\n    KeyCode[KeyCode[\"US_CLOSE_SQUARE_BRACKET\"] = 89] = \"US_CLOSE_SQUARE_BRACKET\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     * For the US standard keyboard, the ''\"' key\r\n     */\r\n    KeyCode[KeyCode[\"US_QUOTE\"] = 90] = \"US_QUOTE\";\r\n    /**\r\n     * Used for miscellaneous characters; it can vary by keyboard.\r\n     */\r\n    KeyCode[KeyCode[\"OEM_8\"] = 91] = \"OEM_8\";\r\n    /**\r\n     * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\r\n     */\r\n    KeyCode[KeyCode[\"OEM_102\"] = 92] = \"OEM_102\";\r\n    KeyCode[KeyCode[\"NUMPAD_0\"] = 93] = \"NUMPAD_0\";\r\n    KeyCode[KeyCode[\"NUMPAD_1\"] = 94] = \"NUMPAD_1\";\r\n    KeyCode[KeyCode[\"NUMPAD_2\"] = 95] = \"NUMPAD_2\";\r\n    KeyCode[KeyCode[\"NUMPAD_3\"] = 96] = \"NUMPAD_3\";\r\n    KeyCode[KeyCode[\"NUMPAD_4\"] = 97] = \"NUMPAD_4\";\r\n    KeyCode[KeyCode[\"NUMPAD_5\"] = 98] = \"NUMPAD_5\";\r\n    KeyCode[KeyCode[\"NUMPAD_6\"] = 99] = \"NUMPAD_6\";\r\n    KeyCode[KeyCode[\"NUMPAD_7\"] = 100] = \"NUMPAD_7\";\r\n    KeyCode[KeyCode[\"NUMPAD_8\"] = 101] = \"NUMPAD_8\";\r\n    KeyCode[KeyCode[\"NUMPAD_9\"] = 102] = \"NUMPAD_9\";\r\n    KeyCode[KeyCode[\"NUMPAD_MULTIPLY\"] = 103] = \"NUMPAD_MULTIPLY\";\r\n    KeyCode[KeyCode[\"NUMPAD_ADD\"] = 104] = \"NUMPAD_ADD\";\r\n    KeyCode[KeyCode[\"NUMPAD_SEPARATOR\"] = 105] = \"NUMPAD_SEPARATOR\";\r\n    KeyCode[KeyCode[\"NUMPAD_SUBTRACT\"] = 106] = \"NUMPAD_SUBTRACT\";\r\n    KeyCode[KeyCode[\"NUMPAD_DECIMAL\"] = 107] = \"NUMPAD_DECIMAL\";\r\n    KeyCode[KeyCode[\"NUMPAD_DIVIDE\"] = 108] = \"NUMPAD_DIVIDE\";\r\n    /**\r\n     * Cover all key codes when IME is processing input.\r\n     */\r\n    KeyCode[KeyCode[\"KEY_IN_COMPOSITION\"] = 109] = \"KEY_IN_COMPOSITION\";\r\n    KeyCode[KeyCode[\"ABNT_C1\"] = 110] = \"ABNT_C1\";\r\n    KeyCode[KeyCode[\"ABNT_C2\"] = 111] = \"ABNT_C2\";\r\n    /**\r\n     * Placed last to cover the length of the enum.\r\n     * Please do not depend on this value!\r\n     */\r\n    KeyCode[KeyCode[\"MAX_VALUE\"] = 112] = \"MAX_VALUE\";\r\n})(KeyCode || (KeyCode = {}));\r\nexport var MarkerSeverity;\r\n(function (MarkerSeverity) {\r\n    MarkerSeverity[MarkerSeverity[\"Hint\"] = 1] = \"Hint\";\r\n    MarkerSeverity[MarkerSeverity[\"Info\"] = 2] = \"Info\";\r\n    MarkerSeverity[MarkerSeverity[\"Warning\"] = 4] = \"Warning\";\r\n    MarkerSeverity[MarkerSeverity[\"Error\"] = 8] = \"Error\";\r\n})(MarkerSeverity || (MarkerSeverity = {}));\r\nexport var MarkerTag;\r\n(function (MarkerTag) {\r\n    MarkerTag[MarkerTag[\"Unnecessary\"] = 1] = \"Unnecessary\";\r\n    MarkerTag[MarkerTag[\"Deprecated\"] = 2] = \"Deprecated\";\r\n})(MarkerTag || (MarkerTag = {}));\r\n/**\r\n * Position in the minimap to render the decoration.\r\n */\r\nexport var MinimapPosition;\r\n(function (MinimapPosition) {\r\n    MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\r\n    MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\r\n})(MinimapPosition || (MinimapPosition = {}));\r\n/**\r\n * Type of hit element with the mouse in the editor.\r\n */\r\nexport var MouseTargetType;\r\n(function (MouseTargetType) {\r\n    /**\r\n     * Mouse is on top of an unknown element.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\r\n    /**\r\n     * Mouse is on top of the textarea used for input.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"TEXTAREA\"] = 1] = \"TEXTAREA\";\r\n    /**\r\n     * Mouse is on top of the glyph margin\r\n     */\r\n    MouseTargetType[MouseTargetType[\"GUTTER_GLYPH_MARGIN\"] = 2] = \"GUTTER_GLYPH_MARGIN\";\r\n    /**\r\n     * Mouse is on top of the line numbers\r\n     */\r\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_NUMBERS\"] = 3] = \"GUTTER_LINE_NUMBERS\";\r\n    /**\r\n     * Mouse is on top of the line decorations\r\n     */\r\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_DECORATIONS\"] = 4] = \"GUTTER_LINE_DECORATIONS\";\r\n    /**\r\n     * Mouse is on top of the whitespace left in the gutter by a view zone.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"GUTTER_VIEW_ZONE\"] = 5] = \"GUTTER_VIEW_ZONE\";\r\n    /**\r\n     * Mouse is on top of text in the content.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"CONTENT_TEXT\"] = 6] = \"CONTENT_TEXT\";\r\n    /**\r\n     * Mouse is on top of empty space in the content (e.g. after line text or below last line)\r\n     */\r\n    MouseTargetType[MouseTargetType[\"CONTENT_EMPTY\"] = 7] = \"CONTENT_EMPTY\";\r\n    /**\r\n     * Mouse is on top of a view zone in the content.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"CONTENT_VIEW_ZONE\"] = 8] = \"CONTENT_VIEW_ZONE\";\r\n    /**\r\n     * Mouse is on top of a content widget.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"CONTENT_WIDGET\"] = 9] = \"CONTENT_WIDGET\";\r\n    /**\r\n     * Mouse is on top of the decorations overview ruler.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"OVERVIEW_RULER\"] = 10] = \"OVERVIEW_RULER\";\r\n    /**\r\n     * Mouse is on top of a scrollbar.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"SCROLLBAR\"] = 11] = \"SCROLLBAR\";\r\n    /**\r\n     * Mouse is on top of an overlay widget.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"OVERLAY_WIDGET\"] = 12] = \"OVERLAY_WIDGET\";\r\n    /**\r\n     * Mouse is outside of the editor.\r\n     */\r\n    MouseTargetType[MouseTargetType[\"OUTSIDE_EDITOR\"] = 13] = \"OUTSIDE_EDITOR\";\r\n})(MouseTargetType || (MouseTargetType = {}));\r\n/**\r\n * A positioning preference for rendering overlay widgets.\r\n */\r\nexport var OverlayWidgetPositionPreference;\r\n(function (OverlayWidgetPositionPreference) {\r\n    /**\r\n     * Position the overlay widget in the top right corner\r\n     */\r\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_RIGHT_CORNER\"] = 0] = \"TOP_RIGHT_CORNER\";\r\n    /**\r\n     * Position the overlay widget in the bottom right corner\r\n     */\r\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"BOTTOM_RIGHT_CORNER\"] = 1] = \"BOTTOM_RIGHT_CORNER\";\r\n    /**\r\n     * Position the overlay widget in the top center\r\n     */\r\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_CENTER\"] = 2] = \"TOP_CENTER\";\r\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\r\n/**\r\n * Vertical Lane in the overview ruler of the editor.\r\n */\r\nexport var OverviewRulerLane;\r\n(function (OverviewRulerLane) {\r\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\r\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\r\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\r\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\r\n})(OverviewRulerLane || (OverviewRulerLane = {}));\r\nexport var RenderLineNumbersType;\r\n(function (RenderLineNumbersType) {\r\n    RenderLineNumbersType[RenderLineNumbersType[\"Off\"] = 0] = \"Off\";\r\n    RenderLineNumbersType[RenderLineNumbersType[\"On\"] = 1] = \"On\";\r\n    RenderLineNumbersType[RenderLineNumbersType[\"Relative\"] = 2] = \"Relative\";\r\n    RenderLineNumbersType[RenderLineNumbersType[\"Interval\"] = 3] = \"Interval\";\r\n    RenderLineNumbersType[RenderLineNumbersType[\"Custom\"] = 4] = \"Custom\";\r\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\r\nexport var RenderMinimap;\r\n(function (RenderMinimap) {\r\n    RenderMinimap[RenderMinimap[\"None\"] = 0] = \"None\";\r\n    RenderMinimap[RenderMinimap[\"Text\"] = 1] = \"Text\";\r\n    RenderMinimap[RenderMinimap[\"Blocks\"] = 2] = \"Blocks\";\r\n})(RenderMinimap || (RenderMinimap = {}));\r\nexport var ScrollType;\r\n(function (ScrollType) {\r\n    ScrollType[ScrollType[\"Smooth\"] = 0] = \"Smooth\";\r\n    ScrollType[ScrollType[\"Immediate\"] = 1] = \"Immediate\";\r\n})(ScrollType || (ScrollType = {}));\r\nexport var ScrollbarVisibility;\r\n(function (ScrollbarVisibility) {\r\n    ScrollbarVisibility[ScrollbarVisibility[\"Auto\"] = 1] = \"Auto\";\r\n    ScrollbarVisibility[ScrollbarVisibility[\"Hidden\"] = 2] = \"Hidden\";\r\n    ScrollbarVisibility[ScrollbarVisibility[\"Visible\"] = 3] = \"Visible\";\r\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\r\n/**\r\n * The direction of a selection.\r\n */\r\nexport var SelectionDirection;\r\n(function (SelectionDirection) {\r\n    /**\r\n     * The selection starts above where it ends.\r\n     */\r\n    SelectionDirection[SelectionDirection[\"LTR\"] = 0] = \"LTR\";\r\n    /**\r\n     * The selection starts below where it ends.\r\n     */\r\n    SelectionDirection[SelectionDirection[\"RTL\"] = 1] = \"RTL\";\r\n})(SelectionDirection || (SelectionDirection = {}));\r\nexport var SignatureHelpTriggerKind;\r\n(function (SignatureHelpTriggerKind) {\r\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\r\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\r\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\r\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\r\n/**\r\n * A symbol kind.\r\n */\r\nexport var SymbolKind;\r\n(function (SymbolKind) {\r\n    SymbolKind[SymbolKind[\"File\"] = 0] = \"File\";\r\n    SymbolKind[SymbolKind[\"Module\"] = 1] = \"Module\";\r\n    SymbolKind[SymbolKind[\"Namespace\"] = 2] = \"Namespace\";\r\n    SymbolKind[SymbolKind[\"Package\"] = 3] = \"Package\";\r\n    SymbolKind[SymbolKind[\"Class\"] = 4] = \"Class\";\r\n    SymbolKind[SymbolKind[\"Method\"] = 5] = \"Method\";\r\n    SymbolKind[SymbolKind[\"Property\"] = 6] = \"Property\";\r\n    SymbolKind[SymbolKind[\"Field\"] = 7] = \"Field\";\r\n    SymbolKind[SymbolKind[\"Constructor\"] = 8] = \"Constructor\";\r\n    SymbolKind[SymbolKind[\"Enum\"] = 9] = \"Enum\";\r\n    SymbolKind[SymbolKind[\"Interface\"] = 10] = \"Interface\";\r\n    SymbolKind[SymbolKind[\"Function\"] = 11] = \"Function\";\r\n    SymbolKind[SymbolKind[\"Variable\"] = 12] = \"Variable\";\r\n    SymbolKind[SymbolKind[\"Constant\"] = 13] = \"Constant\";\r\n    SymbolKind[SymbolKind[\"String\"] = 14] = \"String\";\r\n    SymbolKind[SymbolKind[\"Number\"] = 15] = \"Number\";\r\n    SymbolKind[SymbolKind[\"Boolean\"] = 16] = \"Boolean\";\r\n    SymbolKind[SymbolKind[\"Array\"] = 17] = \"Array\";\r\n    SymbolKind[SymbolKind[\"Object\"] = 18] = \"Object\";\r\n    SymbolKind[SymbolKind[\"Key\"] = 19] = \"Key\";\r\n    SymbolKind[SymbolKind[\"Null\"] = 20] = \"Null\";\r\n    SymbolKind[SymbolKind[\"EnumMember\"] = 21] = \"EnumMember\";\r\n    SymbolKind[SymbolKind[\"Struct\"] = 22] = \"Struct\";\r\n    SymbolKind[SymbolKind[\"Event\"] = 23] = \"Event\";\r\n    SymbolKind[SymbolKind[\"Operator\"] = 24] = \"Operator\";\r\n    SymbolKind[SymbolKind[\"TypeParameter\"] = 25] = \"TypeParameter\";\r\n})(SymbolKind || (SymbolKind = {}));\r\nexport var SymbolTag;\r\n(function (SymbolTag) {\r\n    SymbolTag[SymbolTag[\"Deprecated\"] = 1] = \"Deprecated\";\r\n})(SymbolTag || (SymbolTag = {}));\r\n/**\r\n * The kind of animation in which the editor's cursor should be rendered.\r\n */\r\nexport var TextEditorCursorBlinkingStyle;\r\n(function (TextEditorCursorBlinkingStyle) {\r\n    /**\r\n     * Hidden\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Hidden\"] = 0] = \"Hidden\";\r\n    /**\r\n     * Blinking\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Blink\"] = 1] = \"Blink\";\r\n    /**\r\n     * Blinking with smooth fading\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Smooth\"] = 2] = \"Smooth\";\r\n    /**\r\n     * Blinking with prolonged filled state and smooth fading\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Phase\"] = 3] = \"Phase\";\r\n    /**\r\n     * Expand collapse animation on the y axis\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Expand\"] = 4] = \"Expand\";\r\n    /**\r\n     * No-Blinking\r\n     */\r\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Solid\"] = 5] = \"Solid\";\r\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\r\n/**\r\n * The style in which the editor's cursor should be rendered.\r\n */\r\nexport var TextEditorCursorStyle;\r\n(function (TextEditorCursorStyle) {\r\n    /**\r\n     * As a vertical line (sitting between two characters).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Line\"] = 1] = \"Line\";\r\n    /**\r\n     * As a block (sitting on top of a character).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Block\"] = 2] = \"Block\";\r\n    /**\r\n     * As a horizontal line (sitting under a character).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Underline\"] = 3] = \"Underline\";\r\n    /**\r\n     * As a thin vertical line (sitting between two characters).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"LineThin\"] = 4] = \"LineThin\";\r\n    /**\r\n     * As an outlined block (sitting on top of a character).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"BlockOutline\"] = 5] = \"BlockOutline\";\r\n    /**\r\n     * As a thin horizontal line (sitting under a character).\r\n     */\r\n    TextEditorCursorStyle[TextEditorCursorStyle[\"UnderlineThin\"] = 6] = \"UnderlineThin\";\r\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\r\n/**\r\n * Describes the behavior of decorations when typing/editing near their edges.\r\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\r\n */\r\nexport var TrackedRangeStickiness;\r\n(function (TrackedRangeStickiness) {\r\n    TrackedRangeStickiness[TrackedRangeStickiness[\"AlwaysGrowsWhenTypingAtEdges\"] = 0] = \"AlwaysGrowsWhenTypingAtEdges\";\r\n    TrackedRangeStickiness[TrackedRangeStickiness[\"NeverGrowsWhenTypingAtEdges\"] = 1] = \"NeverGrowsWhenTypingAtEdges\";\r\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingBefore\"] = 2] = \"GrowsOnlyWhenTypingBefore\";\r\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingAfter\"] = 3] = \"GrowsOnlyWhenTypingAfter\";\r\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\r\n/**\r\n * Describes how to indent wrapped lines.\r\n */\r\nexport var WrappingIndent;\r\n(function (WrappingIndent) {\r\n    /**\r\n     * No indentation => wrapped lines begin at column 1.\r\n     */\r\n    WrappingIndent[WrappingIndent[\"None\"] = 0] = \"None\";\r\n    /**\r\n     * Same => wrapped lines get the same indentation as the parent.\r\n     */\r\n    WrappingIndent[WrappingIndent[\"Same\"] = 1] = \"Same\";\r\n    /**\r\n     * Indent => wrapped lines get +1 indentation toward the parent.\r\n     */\r\n    WrappingIndent[WrappingIndent[\"Indent\"] = 2] = \"Indent\";\r\n    /**\r\n     * DeepIndent => wrapped lines get +2 indentation toward the parent.\r\n     */\r\n    WrappingIndent[WrappingIndent[\"DeepIndent\"] = 3] = \"DeepIndent\";\r\n})(WrappingIndent || (WrappingIndent = {}));\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nimport { Position } from './position.js';\r\nimport { Range } from './range.js';\r\n/**\r\n * A selection in the editor.\r\n * The selection is a range that has an orientation.\r\n */\r\nvar Selection = /** @class */ (function (_super) {\r\n    __extends(Selection, _super);\r\n    function Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\r\n        var _this = _super.call(this, selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) || this;\r\n        _this.selectionStartLineNumber = selectionStartLineNumber;\r\n        _this.selectionStartColumn = selectionStartColumn;\r\n        _this.positionLineNumber = positionLineNumber;\r\n        _this.positionColumn = positionColumn;\r\n        return _this;\r\n    }\r\n    /**\r\n     * Transform to a human-readable representation.\r\n     */\r\n    Selection.prototype.toString = function () {\r\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\r\n    };\r\n    /**\r\n     * Test if equals other selection.\r\n     */\r\n    Selection.prototype.equalsSelection = function (other) {\r\n        return (Selection.selectionsEqual(this, other));\r\n    };\r\n    /**\r\n     * Test if the two selections are equal.\r\n     */\r\n    Selection.selectionsEqual = function (a, b) {\r\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\r\n            a.selectionStartColumn === b.selectionStartColumn &&\r\n            a.positionLineNumber === b.positionLineNumber &&\r\n            a.positionColumn === b.positionColumn);\r\n    };\r\n    /**\r\n     * Get directions (LTR or RTL).\r\n     */\r\n    Selection.prototype.getDirection = function () {\r\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\r\n            return 0 /* LTR */;\r\n        }\r\n        return 1 /* RTL */;\r\n    };\r\n    /**\r\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\r\n     */\r\n    Selection.prototype.setEndPosition = function (endLineNumber, endColumn) {\r\n        if (this.getDirection() === 0 /* LTR */) {\r\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\r\n        }\r\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\r\n    };\r\n    /**\r\n     * Get the position at `positionLineNumber` and `positionColumn`.\r\n     */\r\n    Selection.prototype.getPosition = function () {\r\n        return new Position(this.positionLineNumber, this.positionColumn);\r\n    };\r\n    /**\r\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\r\n     */\r\n    Selection.prototype.setStartPosition = function (startLineNumber, startColumn) {\r\n        if (this.getDirection() === 0 /* LTR */) {\r\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\r\n        }\r\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\r\n    };\r\n    // ----\r\n    /**\r\n     * Create a `Selection` from one or two positions\r\n     */\r\n    Selection.fromPositions = function (start, end) {\r\n        if (end === void 0) { end = start; }\r\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\r\n    };\r\n    /**\r\n     * Create a `Selection` from an `ISelection`.\r\n     */\r\n    Selection.liftSelection = function (sel) {\r\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\r\n    };\r\n    /**\r\n     * `a` equals `b`.\r\n     */\r\n    Selection.selectionsArrEqual = function (a, b) {\r\n        if (a && !b || !a && b) {\r\n            return false;\r\n        }\r\n        if (!a && !b) {\r\n            return true;\r\n        }\r\n        if (a.length !== b.length) {\r\n            return false;\r\n        }\r\n        for (var i = 0, len = a.length; i < len; i++) {\r\n            if (!this.selectionsEqual(a[i], b[i])) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    };\r\n    /**\r\n     * Test if `obj` is an `ISelection`.\r\n     */\r\n    Selection.isISelection = function (obj) {\r\n        return (obj\r\n            && (typeof obj.selectionStartLineNumber === 'number')\r\n            && (typeof obj.selectionStartColumn === 'number')\r\n            && (typeof obj.positionLineNumber === 'number')\r\n            && (typeof obj.positionColumn === 'number'));\r\n    };\r\n    /**\r\n     * Create with a direction.\r\n     */\r\n    Selection.createWithDirection = function (startLineNumber, startColumn, endLineNumber, endColumn, direction) {\r\n        if (direction === 0 /* LTR */) {\r\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\r\n        }\r\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\r\n    };\r\n    return Selection;\r\n}(Range));\r\nexport { Selection };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar Token = /** @class */ (function () {\r\n    function Token(offset, type, language) {\r\n        this.offset = offset | 0; // @perf\r\n        this.type = type;\r\n        this.language = language;\r\n    }\r\n    Token.prototype.toString = function () {\r\n        return '(' + this.offset + ', ' + this.type + ')';\r\n    };\r\n    return Token;\r\n}());\r\nexport { Token };\r\nvar TokenizationResult = /** @class */ (function () {\r\n    function TokenizationResult(tokens, endState) {\r\n        this.tokens = tokens;\r\n        this.endState = endState;\r\n    }\r\n    return TokenizationResult;\r\n}());\r\nexport { TokenizationResult };\r\nvar TokenizationResult2 = /** @class */ (function () {\r\n    function TokenizationResult2(tokens, endState) {\r\n        this.tokens = tokens;\r\n        this.endState = endState;\r\n    }\r\n    return TokenizationResult2;\r\n}());\r\nexport { TokenizationResult2 };\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport './promise-polyfill/polyfill.js';\r\nimport { CancellationTokenSource } from '../../../base/common/cancellation.js';\r\nimport { Emitter } from '../../../base/common/event.js';\r\nimport { KeyChord } from '../../../base/common/keyCodes.js';\r\nimport { URI } from '../../../base/common/uri.js';\r\nimport { Position } from '../core/position.js';\r\nimport { Range } from '../core/range.js';\r\nimport { Selection } from '../core/selection.js';\r\nimport { Token } from '../core/token.js';\r\nimport * as standaloneEnums from './standaloneEnums.js';\r\nvar KeyMod = /** @class */ (function () {\r\n    function KeyMod() {\r\n    }\r\n    KeyMod.chord = function (firstPart, secondPart) {\r\n        return KeyChord(firstPart, secondPart);\r\n    };\r\n    KeyMod.CtrlCmd = 2048 /* CtrlCmd */;\r\n    KeyMod.Shift = 1024 /* Shift */;\r\n    KeyMod.Alt = 512 /* Alt */;\r\n    KeyMod.WinCtrl = 256 /* WinCtrl */;\r\n    return KeyMod;\r\n}());\r\nexport { KeyMod };\r\nexport function createMonacoBaseAPI() {\r\n    return {\r\n        editor: undefined,\r\n        languages: undefined,\r\n        CancellationTokenSource: CancellationTokenSource,\r\n        Emitter: Emitter,\r\n        KeyCode: standaloneEnums.KeyCode,\r\n        KeyMod: KeyMod,\r\n        Position: Position,\r\n        Range: Range,\r\n        Selection: Selection,\r\n        SelectionDirection: standaloneEnums.SelectionDirection,\r\n        MarkerSeverity: standaloneEnums.MarkerSeverity,\r\n        MarkerTag: standaloneEnums.MarkerTag,\r\n        Uri: URI,\r\n        Token: Token\r\n    };\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n};\r\nvar __generator = (this && this.__generator) || function (thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n};\r\nimport { mergeSort } from '../../../base/common/arrays.js';\r\nimport { stringDiff } from '../../../base/common/diff/diff.js';\r\nimport { FIN } from '../../../base/common/iterator.js';\r\nimport { globals } from '../../../base/common/platform.js';\r\nimport { URI } from '../../../base/common/uri.js';\r\nimport { Position } from '../core/position.js';\r\nimport { Range } from '../core/range.js';\r\nimport { DiffComputer } from '../diff/diffComputer.js';\r\nimport { MirrorTextModel as BaseMirrorModel } from '../model/mirrorTextModel.js';\r\nimport { ensureValidWordDefinition, getWordAtText } from '../model/wordHelper.js';\r\nimport { computeLinks } from '../modes/linkComputer.js';\r\nimport { BasicInplaceReplace } from '../modes/supports/inplaceReplaceSupport.js';\r\nimport { createMonacoBaseAPI } from '../standalone/standaloneBase.js';\r\nimport * as types from '../../../base/common/types.js';\r\n/**\r\n * @internal\r\n */\r\nvar MirrorModel = /** @class */ (function (_super) {\r\n    __extends(MirrorModel, _super);\r\n    function MirrorModel() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    Object.defineProperty(MirrorModel.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(MirrorModel.prototype, \"version\", {\r\n        get: function () {\r\n            return this._versionId;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    Object.defineProperty(MirrorModel.prototype, \"eol\", {\r\n        get: function () {\r\n            return this._eol;\r\n        },\r\n        enumerable: true,\r\n        configurable: true\r\n    });\r\n    MirrorModel.prototype.getValue = function () {\r\n        return this.getText();\r\n    };\r\n    MirrorModel.prototype.getLinesContent = function () {\r\n        return this._lines.slice(0);\r\n    };\r\n    MirrorModel.prototype.getLineCount = function () {\r\n        return this._lines.length;\r\n    };\r\n    MirrorModel.prototype.getLineContent = function (lineNumber) {\r\n        return this._lines[lineNumber - 1];\r\n    };\r\n    MirrorModel.prototype.getWordAtPosition = function (position, wordDefinition) {\r\n        var wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);\r\n        if (wordAtText) {\r\n            return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\r\n        }\r\n        return null;\r\n    };\r\n    MirrorModel.prototype.createWordIterator = function (wordDefinition) {\r\n        var _this = this;\r\n        var obj;\r\n        var lineNumber = 0;\r\n        var lineText;\r\n        var wordRangesIdx = 0;\r\n        var wordRanges = [];\r\n        var next = function () {\r\n            if (wordRangesIdx < wordRanges.length) {\r\n                var value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\r\n                wordRangesIdx += 1;\r\n                if (!obj) {\r\n                    obj = { done: false, value: value };\r\n                }\r\n                else {\r\n                    obj.value = value;\r\n                }\r\n                return obj;\r\n            }\r\n            else if (lineNumber >= _this._lines.length) {\r\n                return FIN;\r\n            }\r\n            else {\r\n                lineText = _this._lines[lineNumber];\r\n                wordRanges = _this._wordenize(lineText, wordDefinition);\r\n                wordRangesIdx = 0;\r\n                lineNumber += 1;\r\n                return next();\r\n            }\r\n        };\r\n        return { next: next };\r\n    };\r\n    MirrorModel.prototype.getLineWords = function (lineNumber, wordDefinition) {\r\n        var content = this._lines[lineNumber - 1];\r\n        var ranges = this._wordenize(content, wordDefinition);\r\n        var words = [];\r\n        for (var _i = 0, ranges_1 = ranges; _i < ranges_1.length; _i++) {\r\n            var range = ranges_1[_i];\r\n            words.push({\r\n                word: content.substring(range.start, range.end),\r\n                startColumn: range.start + 1,\r\n                endColumn: range.end + 1\r\n            });\r\n        }\r\n        return words;\r\n    };\r\n    MirrorModel.prototype._wordenize = function (content, wordDefinition) {\r\n        var result = [];\r\n        var match;\r\n        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\r\n        while (match = wordDefinition.exec(content)) {\r\n            if (match[0].length === 0) {\r\n                // it did match the empty string\r\n                break;\r\n            }\r\n            result.push({ start: match.index, end: match.index + match[0].length });\r\n        }\r\n        return result;\r\n    };\r\n    MirrorModel.prototype.getValueInRange = function (range) {\r\n        range = this._validateRange(range);\r\n        if (range.startLineNumber === range.endLineNumber) {\r\n            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\r\n        }\r\n        var lineEnding = this._eol;\r\n        var startLineIndex = range.startLineNumber - 1;\r\n        var endLineIndex = range.endLineNumber - 1;\r\n        var resultLines = [];\r\n        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\r\n        for (var i = startLineIndex + 1; i < endLineIndex; i++) {\r\n            resultLines.push(this._lines[i]);\r\n        }\r\n        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\r\n        return resultLines.join(lineEnding);\r\n    };\r\n    MirrorModel.prototype.offsetAt = function (position) {\r\n        position = this._validatePosition(position);\r\n        this._ensureLineStarts();\r\n        return this._lineStarts.getAccumulatedValue(position.lineNumber - 2) + (position.column - 1);\r\n    };\r\n    MirrorModel.prototype.positionAt = function (offset) {\r\n        offset = Math.floor(offset);\r\n        offset = Math.max(0, offset);\r\n        this._ensureLineStarts();\r\n        var out = this._lineStarts.getIndexOf(offset);\r\n        var lineLength = this._lines[out.index].length;\r\n        // Ensure we return a valid position\r\n        return {\r\n            lineNumber: 1 + out.index,\r\n            column: 1 + Math.min(out.remainder, lineLength)\r\n        };\r\n    };\r\n    MirrorModel.prototype._validateRange = function (range) {\r\n        var start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\r\n        var end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\r\n        if (start.lineNumber !== range.startLineNumber\r\n            || start.column !== range.startColumn\r\n            || end.lineNumber !== range.endLineNumber\r\n            || end.column !== range.endColumn) {\r\n            return {\r\n                startLineNumber: start.lineNumber,\r\n                startColumn: start.column,\r\n                endLineNumber: end.lineNumber,\r\n                endColumn: end.column\r\n            };\r\n        }\r\n        return range;\r\n    };\r\n    MirrorModel.prototype._validatePosition = function (position) {\r\n        if (!Position.isIPosition(position)) {\r\n            throw new Error('bad position');\r\n        }\r\n        var lineNumber = position.lineNumber, column = position.column;\r\n        var hasChanged = false;\r\n        if (lineNumber < 1) {\r\n            lineNumber = 1;\r\n            column = 1;\r\n            hasChanged = true;\r\n        }\r\n        else if (lineNumber > this._lines.length) {\r\n            lineNumber = this._lines.length;\r\n            column = this._lines[lineNumber - 1].length + 1;\r\n            hasChanged = true;\r\n        }\r\n        else {\r\n            var maxCharacter = this._lines[lineNumber - 1].length + 1;\r\n            if (column < 1) {\r\n                column = 1;\r\n                hasChanged = true;\r\n            }\r\n            else if (column > maxCharacter) {\r\n                column = maxCharacter;\r\n                hasChanged = true;\r\n            }\r\n        }\r\n        if (!hasChanged) {\r\n            return position;\r\n        }\r\n        else {\r\n            return { lineNumber: lineNumber, column: column };\r\n        }\r\n    };\r\n    return MirrorModel;\r\n}(BaseMirrorModel));\r\n/**\r\n * @internal\r\n */\r\nvar EditorSimpleWorker = /** @class */ (function () {\r\n    function EditorSimpleWorker(host, foreignModuleFactory) {\r\n        this._host = host;\r\n        this._models = Object.create(null);\r\n        this._foreignModuleFactory = foreignModuleFactory;\r\n        this._foreignModule = null;\r\n    }\r\n    EditorSimpleWorker.prototype.dispose = function () {\r\n        this._models = Object.create(null);\r\n    };\r\n    EditorSimpleWorker.prototype._getModel = function (uri) {\r\n        return this._models[uri];\r\n    };\r\n    EditorSimpleWorker.prototype._getModels = function () {\r\n        var _this = this;\r\n        var all = [];\r\n        Object.keys(this._models).forEach(function (key) { return all.push(_this._models[key]); });\r\n        return all;\r\n    };\r\n    EditorSimpleWorker.prototype.acceptNewModel = function (data) {\r\n        this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\r\n    };\r\n    EditorSimpleWorker.prototype.acceptModelChanged = function (strURL, e) {\r\n        if (!this._models[strURL]) {\r\n            return;\r\n        }\r\n        var model = this._models[strURL];\r\n        model.onEvents(e);\r\n    };\r\n    EditorSimpleWorker.prototype.acceptRemovedModel = function (strURL) {\r\n        if (!this._models[strURL]) {\r\n            return;\r\n        }\r\n        delete this._models[strURL];\r\n    };\r\n    // ---- BEGIN diff --------------------------------------------------------------------------\r\n    EditorSimpleWorker.prototype.computeDiff = function (originalUrl, modifiedUrl, ignoreTrimWhitespace, maxComputationTime) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var original, modified, originalLines, modifiedLines, diffComputer, diffResult, identical;\r\n            return __generator(this, function (_a) {\r\n                original = this._getModel(originalUrl);\r\n                modified = this._getModel(modifiedUrl);\r\n                if (!original || !modified) {\r\n                    return [2 /*return*/, null];\r\n                }\r\n                originalLines = original.getLinesContent();\r\n                modifiedLines = modified.getLinesContent();\r\n                diffComputer = new DiffComputer(originalLines, modifiedLines, {\r\n                    shouldComputeCharChanges: true,\r\n                    shouldPostProcessCharChanges: true,\r\n                    shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\r\n                    shouldMakePrettyDiff: true,\r\n                    maxComputationTime: maxComputationTime\r\n                });\r\n                diffResult = diffComputer.computeDiff();\r\n                identical = (diffResult.changes.length > 0 ? false : this._modelsAreIdentical(original, modified));\r\n                return [2 /*return*/, {\r\n                        quitEarly: diffResult.quitEarly,\r\n                        identical: identical,\r\n                        changes: diffResult.changes\r\n                    }];\r\n            });\r\n        });\r\n    };\r\n    EditorSimpleWorker.prototype._modelsAreIdentical = function (original, modified) {\r\n        var originalLineCount = original.getLineCount();\r\n        var modifiedLineCount = modified.getLineCount();\r\n        if (originalLineCount !== modifiedLineCount) {\r\n            return false;\r\n        }\r\n        for (var line = 1; line <= originalLineCount; line++) {\r\n            var originalLine = original.getLineContent(line);\r\n            var modifiedLine = modified.getLineContent(line);\r\n            if (originalLine !== modifiedLine) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    };\r\n    EditorSimpleWorker.prototype.computeMoreMinimalEdits = function (modelUrl, edits) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var model, result, lastEol, _i, edits_1, _a, range, text, eol, original, changes, editOffset, _b, changes_1, change, start, end, newEdit;\r\n            return __generator(this, function (_c) {\r\n                model = this._getModel(modelUrl);\r\n                if (!model) {\r\n                    return [2 /*return*/, edits];\r\n                }\r\n                result = [];\r\n                lastEol = undefined;\r\n                edits = mergeSort(edits, function (a, b) {\r\n                    if (a.range && b.range) {\r\n                        return Range.compareRangesUsingStarts(a.range, b.range);\r\n                    }\r\n                    // eol only changes should go to the end\r\n                    var aRng = a.range ? 0 : 1;\r\n                    var bRng = b.range ? 0 : 1;\r\n                    return aRng - bRng;\r\n                });\r\n                for (_i = 0, edits_1 = edits; _i < edits_1.length; _i++) {\r\n                    _a = edits_1[_i], range = _a.range, text = _a.text, eol = _a.eol;\r\n                    if (typeof eol === 'number') {\r\n                        lastEol = eol;\r\n                    }\r\n                    if (Range.isEmpty(range) && !text) {\r\n                        // empty change\r\n                        continue;\r\n                    }\r\n                    original = model.getValueInRange(range);\r\n                    text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\r\n                    if (original === text) {\r\n                        // noop\r\n                        continue;\r\n                    }\r\n                    // make sure diff won't take too long\r\n                    if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {\r\n                        result.push({ range: range, text: text });\r\n                        continue;\r\n                    }\r\n                    changes = stringDiff(original, text, false);\r\n                    editOffset = model.offsetAt(Range.lift(range).getStartPosition());\r\n                    for (_b = 0, changes_1 = changes; _b < changes_1.length; _b++) {\r\n                        change = changes_1[_b];\r\n                        start = model.positionAt(editOffset + change.originalStart);\r\n                        end = model.positionAt(editOffset + change.originalStart + change.originalLength);\r\n                        newEdit = {\r\n                            text: text.substr(change.modifiedStart, change.modifiedLength),\r\n                            range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\r\n                        };\r\n                        if (model.getValueInRange(newEdit.range) !== newEdit.text) {\r\n                            result.push(newEdit);\r\n                        }\r\n                    }\r\n                }\r\n                if (typeof lastEol === 'number') {\r\n                    result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\r\n                }\r\n                return [2 /*return*/, result];\r\n            });\r\n        });\r\n    };\r\n    // ---- END minimal edits ---------------------------------------------------------------\r\n    EditorSimpleWorker.prototype.computeLinks = function (modelUrl) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var model;\r\n            return __generator(this, function (_a) {\r\n                model = this._getModel(modelUrl);\r\n                if (!model) {\r\n                    return [2 /*return*/, null];\r\n                }\r\n                return [2 /*return*/, computeLinks(model)];\r\n            });\r\n        });\r\n    };\r\n    EditorSimpleWorker.prototype.textualSuggest = function (modelUrl, position, wordDef, wordDefFlags) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var model, words, seen, wordDefRegExp, wordAt, iter, e, word;\r\n            return __generator(this, function (_a) {\r\n                model = this._getModel(modelUrl);\r\n                if (!model) {\r\n                    return [2 /*return*/, null];\r\n                }\r\n                words = [];\r\n                seen = new Set();\r\n                wordDefRegExp = new RegExp(wordDef, wordDefFlags);\r\n                wordAt = model.getWordAtPosition(position, wordDefRegExp);\r\n                if (wordAt) {\r\n                    seen.add(model.getValueInRange(wordAt));\r\n                }\r\n                for (iter = model.createWordIterator(wordDefRegExp), e = iter.next(); !e.done && seen.size <= EditorSimpleWorker._suggestionsLimit; e = iter.next()) {\r\n                    word = e.value;\r\n                    if (seen.has(word)) {\r\n                        continue;\r\n                    }\r\n                    seen.add(word);\r\n                    if (!isNaN(Number(word))) {\r\n                        continue;\r\n                    }\r\n                    words.push(word);\r\n                }\r\n                return [2 /*return*/, words];\r\n            });\r\n        });\r\n    };\r\n    // ---- END suggest --------------------------------------------------------------------------\r\n    //#region -- word ranges --\r\n    EditorSimpleWorker.prototype.computeWordRanges = function (modelUrl, range, wordDef, wordDefFlags) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var model, wordDefRegExp, result, line, words, _i, words_1, word, array;\r\n            return __generator(this, function (_a) {\r\n                model = this._getModel(modelUrl);\r\n                if (!model) {\r\n                    return [2 /*return*/, Object.create(null)];\r\n                }\r\n                wordDefRegExp = new RegExp(wordDef, wordDefFlags);\r\n                result = Object.create(null);\r\n                for (line = range.startLineNumber; line < range.endLineNumber; line++) {\r\n                    words = model.getLineWords(line, wordDefRegExp);\r\n                    for (_i = 0, words_1 = words; _i < words_1.length; _i++) {\r\n                        word = words_1[_i];\r\n                        if (!isNaN(Number(word.word))) {\r\n                            continue;\r\n                        }\r\n                        array = result[word.word];\r\n                        if (!array) {\r\n                            array = [];\r\n                            result[word.word] = array;\r\n                        }\r\n                        array.push({\r\n                            startLineNumber: line,\r\n                            startColumn: word.startColumn,\r\n                            endLineNumber: line,\r\n                            endColumn: word.endColumn\r\n                        });\r\n                    }\r\n                }\r\n                return [2 /*return*/, result];\r\n            });\r\n        });\r\n    };\r\n    //#endregion\r\n    EditorSimpleWorker.prototype.navigateValueSet = function (modelUrl, range, up, wordDef, wordDefFlags) {\r\n        return __awaiter(this, void 0, void 0, function () {\r\n            var model, wordDefRegExp, selectionText, wordRange, word, result;\r\n            return __generator(this, function (_a) {\r\n                model = this._getModel(modelUrl);\r\n                if (!model) {\r\n                    return [2 /*return*/, null];\r\n                }\r\n                wordDefRegExp = new RegExp(wordDef, wordDefFlags);\r\n                if (range.startColumn === range.endColumn) {\r\n                    range = {\r\n                        startLineNumber: range.startLineNumber,\r\n                        startColumn: range.startColumn,\r\n                        endLineNumber: range.endLineNumber,\r\n                        endColumn: range.endColumn + 1\r\n                    };\r\n                }\r\n                selectionText = model.getValueInRange(range);\r\n                wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\r\n                if (!wordRange) {\r\n                    return [2 /*return*/, null];\r\n                }\r\n                word = model.getValueInRange(wordRange);\r\n                result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\r\n                return [2 /*return*/, result];\r\n            });\r\n        });\r\n    };\r\n    // ---- BEGIN foreign module support --------------------------------------------------------------------------\r\n    EditorSimpleWorker.prototype.loadForeignModule = function (moduleId, createData, foreignHostMethods) {\r\n        var _this = this;\r\n        var proxyMethodRequest = function (method, args) {\r\n            return _this._host.fhr(method, args);\r\n        };\r\n        var foreignHost = types.createProxyObject(foreignHostMethods, proxyMethodRequest);\r\n        var ctx = {\r\n            host: foreignHost,\r\n            getMirrorModels: function () {\r\n                return _this._getModels();\r\n            }\r\n        };\r\n        if (this._foreignModuleFactory) {\r\n            this._foreignModule = this._foreignModuleFactory(ctx, createData);\r\n            // static foreing module\r\n            return Promise.resolve(types.getAllMethodNames(this._foreignModule));\r\n        }\r\n        // ESM-comment-begin\r\n        // \t\treturn new Promise<any>((resolve, reject) => {\r\n        // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\r\n        // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\r\n        // \r\n        // \t\t\t\tresolve(types.getAllMethodNames(this._foreignModule));\r\n        // \r\n        // \t\t\t}, reject);\r\n        // \t\t});\r\n        // ESM-comment-end\r\n        // ESM-uncomment-begin\r\n        return Promise.reject(new Error(\"Unexpected usage\"));\r\n        // ESM-uncomment-end\r\n    };\r\n    // foreign method request\r\n    EditorSimpleWorker.prototype.fmr = function (method, args) {\r\n        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\r\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\r\n        }\r\n        try {\r\n            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\r\n        }\r\n        catch (e) {\r\n            return Promise.reject(e);\r\n        }\r\n    };\r\n    // ---- END diff --------------------------------------------------------------------------\r\n    // ---- BEGIN minimal edits ---------------------------------------------------------------\r\n    EditorSimpleWorker._diffLimit = 100000;\r\n    // ---- BEGIN suggest --------------------------------------------------------------------------\r\n    EditorSimpleWorker._suggestionsLimit = 10000;\r\n    return EditorSimpleWorker;\r\n}());\r\nexport { EditorSimpleWorker };\r\n/**\r\n * Called on the worker side\r\n * @internal\r\n */\r\nexport function create(host) {\r\n    return new EditorSimpleWorker(host, null);\r\n}\r\nif (typeof importScripts === 'function') {\r\n    // Running in a web worker\r\n    globals.monaco = createMonacoBaseAPI();\r\n}\r\n","/*---------------------------------------------------------------------------------------------\r\n *  Copyright (c) Microsoft Corporation. All rights reserved.\r\n *  Licensed under the MIT License. See License.txt in the project root for license information.\r\n *--------------------------------------------------------------------------------------------*/\r\nimport { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';\r\nimport { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';\r\nvar initialized = false;\r\nexport function initialize(foreignModule) {\r\n    if (initialized) {\r\n        return;\r\n    }\r\n    initialized = true;\r\n    var simpleWorker = new SimpleWorkerServer(function (msg) {\r\n        self.postMessage(msg);\r\n    }, function (host) { return new EditorSimpleWorker(host, foreignModule); });\r\n    self.onmessage = function (e) {\r\n        simpleWorker.onmessage(e.data);\r\n    };\r\n}\r\nself.onmessage = function (e) {\r\n    // Ignore first message in this case and initialize if not yet initialized\r\n    if (!initialized) {\r\n        initialize(null);\r\n    }\r\n};\r\n"],"sourceRoot":""}