{"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/base/common/process.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/functional.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/iterator.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/lifecycle.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/linkedList.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/stopwatch.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/event.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/types.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/strings.js","webpack:///./node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.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/path.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/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/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","_a","LANGUAGE_DEFAULT","_isWindows","_isMacintosh","_isLinux","_isLinuxSnap","_isNative","_isWeb","_isIOS","_locale","undefined","_language","_translationsConfigFile","_userAgent","globals","self","global","nodeProcess","vscode","process","isElectronRenderer","versions","electron","type","navigator","platform","env","rawNlsConfig","nlsConfig","JSON","parse","resolved","availableLanguages","locale","e","console","error","userAgent","indexOf","maxTouchPoints","language","_platform","isWindows","isMacintosh","isWeb","setImmediate","postMessage","importScripts","pending","addEventListener","data","vscodeSetImmediateId","len","length","candidate","id","splice","callback","lastId","myId","push","nextTick","_promise","Promise","resolve","then","fn","args","Array","slice","arguments","shift","setTimeout","apply","arch","execPath","title","pid","browser","argv","binding","Error","path","cwd","chdir","dir","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","safeProcess","sandboxProcess","g","this","Function","window","normalizeArray","parts","allowAboveRoot","up","last","unshift","basename","start","end","matchedSlash","charCodeAt","filter","xs","f","res","resolvedPath","resolvedAbsolute","TypeError","charAt","split","join","normalize","isAbsolute","trailingSlash","substr","paths","index","relative","from","to","trim","arr","fromParts","toParts","Math","min","samePartsLength","outputParts","concat","sep","delimiter","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","str","ErrorHandler","listeners","unexpectedErrorHandler","stack","message","forEach","listener","emit","errorHandler","onUnexpectedError","isPromiseCanceledError","transformErrorForSerialization","stacktrace","$isError","canceledName","_this","result","didCall","Iterable","is","thing","iterator","_empty","freeze","empty","single","element","iterable","isEmpty","next","done","first","some","predicate","find","map","iterables","concatNested","reduce","reducer","initialValue","consume","atMost","Number","POSITIVE_INFINITY","consumed","equals","a","b","comparator","at","bt","ai","bi","an","bn","TRACK_DISPOSABLES","disposableTracker","setDisposableTracker","tracker","__is_disposable_tracked__","x","log","child","parent","Disposable","None","disposable","trackDisposable","markAsDisposed","setParentOfDisposable","setParent","setParentOfDisposables","children","MultiDisposeError","errors","super","dispose","arg","isArray","combinedDisposable","disposables","toDisposable","DisposableStore","_toDispose","Set","_isDisposed","clear","values","DISABLE_DISPOSED_WARNING","warn","add","_store","Node","Undefined","prev","LinkedList","_first","_last","_size","node","_insert","atTheEnd","newNode","oldLast","oldFirst","didRemove","_remove","anchor","hasPerformanceNow","performance","now","highResolution","_highResolution","_startTime","_now","_stopTime","Date","Event","once","event","thisArgs","didFire","snapshot","each","signal","any","events","merge","initial","output","emitter","fire","debounce","delay","leading","leakWarningThreshold","subscription","handle","numDebouncedCalls","cur","clearTimeout","_output","latch","cache","firstCall","shouldEmit","isT","buffer","_buffer","flush","ChainableEvent","chain","fromNodeEventEmitter","eventName","onFirstListenerAdd","on","onLastListenerRemove","removeListener","fromDOMEventEmitter","removeEventListener","toPromise","_listenerCount","_invocationCount","_elapsedOverall","_name","_idPool","listenerCount","_stopWatch","elapsed","info","toFixed","_globalLeakWarningThreshold","LeakageMonitor","customThreshold","random","toString","_warnCountdown","_stacks","threshold","Map","count","set","topStack","topCount","options","_disposed","_options","_leakageMon","_perfMon","_profName","_event","_listeners","firstListener","remove","onFirstListenerDidAdd","onListenerDidAdd","removeMonitor","check","size","hasListeners","_b","_deliveryQueue","stop","_c","_d","_e","getAllPropertyNames","obj","proto","getPrototypeOf","getOwnPropertyNames","getAllMethodNames","methods","prop","createProxyObject","methodNames","invoke","createProxyMethod","method","methodName","splitLines","firstNonWhitespaceIndex","chCode","lastNonWhitespaceIndex","startIndex","isUpperAsciiLetter","isHighSurrogate","charCode","isLowSurrogate","computeCodePoint","highSurrogate","lowSurrogate","String","fromCharCode","GraphemeBreakTree","_data","getGraphemeBreakRawData","_INSTANCE","codePoint","nodeCount","nodeIndex","INITIALIZE","RequestMessage","vsWorker","req","ReplyMessage","seq","err","SubscribeEventMessage","EventMessage","UnsubscribeEventMessage","handler","_workerId","_handler","_lastSentReq","_pendingReplies","_pendingEmitters","_pendingEvents","workerId","reject","_send","delete","_handleMessage","msg","_handleReplyMessage","_handleRequestMessage","_handleSubscribeEventMessage","_handleEventMessage","_handleUnsubscribeEventMessage","replyMessage","reply","requestMessage","handleMessage","detail","handleEvent","has","transfer","ArrayBuffer","sendMessage","propertyIsEvent","propertyIsDynamicEvent","test","proxyListen","createProxyDynamicEvent","requestHandlerFactory","_requestHandlerFactory","_requestHandler","_protocol","_handleEvent","initialize","loaderConfig","hostMethods","setWorkerId","proxyMethodRequest","listen","hostProxy","baseUrl","vs","trustedTypesPolicy","catchError","require","config","DiffChange","originalStart","originalLength","modifiedStart","modifiedLength","numberHash","val","initialHashVal","stringHash","hashVal","leftRotate","bits","totalBits","delta","mask","fill","dest","byteLength","leftPad","char","toHexString","bufferOrValue","bitsize","Uint8Array","padStart","_h0","_h1","_h2","_h3","_h4","_buff","_buffDV","DataView","_buffLen","_totalLen","_leftoverHighSurrogate","_finished","strLen","buff","offset","buffLen","leftoverHighSurrogate","nextCharCode","_push","_step","_wrapUp","ml","setUint32","floor","bigBlock32","_bigBlock32","j","getUint32","k","temp","StringDiffSequence","source","characters","Int32Array","stringDiff","original","modified","pretty","ComputeDiff","changes","Debug","condition","MyArray","sourceArray","sourceIndex","destinationArray","destinationIndex","m_changes","m_originalStart","m_modifiedStart","m_originalCount","m_modifiedCount","originalIndex","modifiedIndex","MarkNextChange","reverse","originalSequence","modifiedSequence","continueProcessingPredicate","ContinueProcessingPredicate","_originalSequence","_modifiedSequence","originalStringElements","originalElementsOrHash","originalHasStrings","_getElements","modifiedStringElements","modifiedElementsOrHash","modifiedHasStrings","_hasStrings","_originalStringElements","_originalElementsOrHash","_modifiedStringElements","_modifiedElementsOrHash","m_forwardHistory","m_reverseHistory","sequence","elements","getElements","_isStringArray","hashes","newIndex","ElementsAreEqual","originalElement","_getStrictElement","modifiedElement","getStrictElement","index1","index2","_ComputeDiff","originalEnd","modifiedEnd","quitEarlyArr","ComputeDiffRecursive","PrettifyChanges","quitEarly","Assert","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","historyIndex","diagonal","AddModifiedElement","AddOriginalElement","getReverseChanges","originalStartPoint","modifiedStartPoint","lastForwardChange","max","getOriginalEnd","getModifiedEnd","getChanges","maxDifferences","numDiagonals","numDifferences","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","tempOriginalIndex","abs","WALKTRACE","matchLengthOfLongest","Copy2","change","originalStop","modifiedStop","checkOriginal","checkModified","OriginalElementsAreEqual","ModifiedElementsAreEqual","startStrictEqual","ElementsAreStrictEqual","endStrictEqual","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","touchingPreviousChange","score","aChange","bChange","matchedLength","aOriginalStart","bOriginalEnd","abOriginalLength","aModifiedStart","bModifiedEnd","abModifiedLength","_findBetterContiguousSequence","originalMatchStart","modifiedMatchStart","desiredLength","originalMax","modifiedMax","bestOriginalStart","bestModifiedStart","_contiguousSequenceScore","_OriginalIsBoundary","_ModifiedIsBoundary","originalScore","_OriginalRegionIsBoundary","modifiedScore","_ModifiedRegionIsBoundary","left","right","Copy","diagonalBaseIndex","diagonalsBelow","diagonalsAbove","diffEven","lowerBoundEven","upperBoundEven","CHAR_UPPERCASE_A","CHAR_LOWERCASE_A","CHAR_UPPERCASE_Z","CHAR_LOWERCASE_Z","CHAR_DOT","CHAR_FORWARD_SLASH","CHAR_BACKWARD_SLASH","CHAR_COLON","CHAR_QUESTION_MARK","ErrorInvalidArgType","expected","actual","determiner","replace","validateString","isPathSeparator","isPosixPathSeparator","isWindowsDeviceRoot","normalizeString","separator","lastSegmentLength","lastSlash","dots","lastSlashIndex","lastIndexOf","_format","pathObject","root","base","win32","pathSegments","resolvedDevice","resolvedTail","toLowerCase","rootEnd","device","firstPart","tail","joined","needsReplace","slashCount","firstLen","fromOrig","toOrig","fromStart","fromEnd","fromLen","toStart","toEnd","toLen","lastCommonSep","fromCode","out","extIdx","firstNonSlashEnd","format","ret","posix","trailingSeparator","_schemePattern","_singleSlashStart","_doubleSlashStart","_validateUri","_strict","scheme","authority","query","fragment","_schemeFix","_referenceResolution","_slash","_regexp","schemeOrData","fsPath","with","uriToFsPath","Uri","match","exec","percentDecode","idx","substring","components","uri","pathFragment","newPath","file","skipEncoding","_asFormatted","_formatted","external","_fsPath","_sep","_pathSepMarker","$mid","encodeTable","encodeURIComponentFast","uriComponent","allowSlash","nativeEncodePos","pos","encodeURIComponent","escaped","encodeURIComponentMinimal","keepDriveLetterCasing","encoder","userinfo","decodeURIComponentGraceful","decodeURIComponent","_rEncodedAsHex","Position","lineNumber","column","newLineNumber","newColumn","deltaLineNumber","deltaColumn","other","isBefore","isBeforeOrEqual","aLineNumber","bLineNumber","aColumn","bColumn","startLineNumber","startColumn","endLineNumber","endColumn","range","position","containsPosition","containsRange","otherRange","strictContainsRange","plusRange","intersectRanges","resultStartLineNumber","resultStartColumn","resultEndLineNumber","resultEndColumn","otherStartLineNumber","otherStartColumn","otherEndLineNumber","otherEndColumn","equalsRange","getEndPosition","getStartPosition","collapseToStart","aStartLineNumber","bStartLineNumber","aStartColumn","bStartColumn","aEndLineNumber","bEndLineNumber","aEndColumn","bEndColumn","aExists","bExists","MINIMUM_MATCHING_CHARACTER_LENGTH","computeDiff","diffAlgo","LineSequence","lines","startColumns","endColumns","getFirstNonBlankColumn","getLastNonBlankColumn","_startColumns","_endColumns","shouldIgnoreTrimWhitespace","endIndex","charCodes","lineNumbers","columns","lineContent","col","CharSequence","_charCodes","_lineNumbers","_columns","CharChange","originalStartLineNumber","originalStartColumn","originalEndLineNumber","originalEndColumn","modifiedStartLineNumber","modifiedStartColumn","modifiedEndLineNumber","modifiedEndColumn","diffChange","originalCharSequence","modifiedCharSequence","getStartLineNumber","getStartColumn","getEndLineNumber","getEndColumn","postProcessCharChanges","rawChanges","currChange","originalMatchingLength","modifiedMatchingLength","matchingLength","LineChange","charChanges","originalLineSequence","modifiedLineSequence","continueCharDiff","shouldComputeCharChanges","shouldPostProcessCharChanges","createCharSequence","createFromDiffChange","DiffComputer","originalLines","modifiedLines","opts","shouldMakePrettyDiff","continueLineDiff","createContinueProcessingPredicate","maxComputationTime","diffResult","lineChanges","createFromDiffResult","originalLineIndex","modifiedLineIndex","nextChange","originalLine","modifiedLine","originalChar","modifiedChar","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","txt","defaultValue","maximumRuntime","startTime","toUint8","v","toUint32","PrefixSumIndexOfResult","remainder","_prefixSumIndexOfResultBrand","prefixSum","Uint32Array","prefixSumValidIndex","insertIndex","insertValues","oldValues","oldPrefixSum","insertValuesLen","subarray","maxCount","_getPrefixSum","sum","getTotalSum","low","high","mid","midStop","midStart","eol","versionId","_uri","_lines","_eol","_versionId","_lineStarts","_cachedTextValue","_acceptDeleteRange","_acceptInsertText","text","eolLength","linesLength","lineStartValues","lineIndex","newValue","changeValue","_setLineText","removeValues","insertText","insertLines","newLengths","USUAL_WORD_SEPARATORS","createWordRegExp","allowInWords","RegExp","DEFAULT_WORD_REGEXP","ensureValidWordDefinition","wordDefinition","flags","ignoreCase","multiline","unicode","lastIndex","_defaultConfig","maxLen","windowSize","timeBudget","getWordAtText","textOffset","t1","prevRegexIndex","regexIndex","thisMatch","_findRegexMatchEnclosingPosition","word","stopPos","matchIndex","_defaultValue","_asciiMap","_createAsciiMap","_map","asciiMap","_value","Uint8Matrix","rows","cols","row","StateMachine","edges","maxCharCode","maxState","states","_states","_maxCharCode","currentState","_stateMachine","getStateMachine","_classifier","getClassifier","FORCE_TERMINATION_CHARACTERS","CANNOT_END_WITH_CHARACTERS","LinkComputer","classifier","line","linkBeginIndex","linkEndIndex","lastIncludedCharIndex","chClass","charCodeBeforeLink","lastCharCodeInLink","url","model","stateMachine","lineCount","getLineCount","getLineContent","linkBeginChCode","state","hasOpenParens","hasOpenSquareBracket","inSquareBrackets","hasOpenCurlyBracket","resetStateMachine","_createLink","nextState","computeLinks","BasicInplaceReplace","_defaultValueSet","range1","text1","range2","text2","doNavigateValueSet","numberResult","numberReplace","textReplace","precision","pow","n1","n2","parseFloat","isNaN","valueSetsReplace","valueSets","valueSetReplace","valueSet","INSTANCE","shortcutEvent","context","CancellationToken","isCancellationToken","Cancelled","isCancellationRequested","onCancellationRequested","_isCancelled","_emitter","CancellationTokenSource","_token","_parentListener","cancel","KeyCodeStrMap","_keyCodeToStr","_strToKeyCode","keyCode","uiMap","userSettingsUSMap","userSettingsGeneralMap","EVENT_KEY_CODE_MAP","NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE","scanCodeIntToStr","scanCodeStrToInt","scanCodeLowerCaseStrToInt","IMMUTABLE_CODE_TO_KEY_CODE","IMMUTABLE_KEY_CODE_TO_CODE","KeyCodeUtils","AccessibilitySupport","CompletionItemInsertTextRule","CompletionItemKind","CompletionItemTag","CompletionTriggerKind","ContentWidgetPositionPreference","CursorChangeReason","DefaultEndOfLine","DocumentHighlightKind","EditorAutoIndentStrategy","EditorOption","EndOfLinePreference","EndOfLineSequence","IndentAction","InlayHintKind","InlineCompletionTriggerKind","KeyCode","MarkerSeverity","MarkerTag","MinimapPosition","MouseTargetType","OverlayWidgetPositionPreference","OverviewRulerLane","RenderLineNumbersType","RenderMinimap","ScrollType","ScrollbarVisibility","SelectionDirection","SignatureHelpTriggerKind","SymbolKind","SymbolTag","TextEditorCursorBlinkingStyle","TextEditorCursorStyle","TrackedRangeStickiness","WrappingIndent","KeyChord","secondPart","chordPart","mappings","seenKeyCode","seenScanCode","mapping","_keyCodeOrd","immutable","scanCode","scanCodeStr","keyCodeStr","eventKeyCode","vkey","usUserSettingsLabel","generalUserSettingsLabel","define","keyCodeToStr","fromString","strToKeyCode","toUserSettingsUS","toUserSettingsGeneral","fromUserSettings","toElectronAccelerator","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","selectionsEqual","getDirection","sel","direction","Token","_tokenBrand","createMonacoBaseAPI","editor","languages","Emitter","KeyMod","Range","Selection","CtrlCmd","Shift","Alt","WinCtrl","__awaiter","thisArg","_arguments","P","generator","adopt","fulfilled","step","rejected","getText","wordAtText","wordenize","_wordenize","lineText","wordRangesIdx","wordRanges","content","ranges","words","_validateRange","lineEnding","startLineIndex","endLineIndex","resultLines","_validatePosition","_ensureLineStarts","getPrefixSum","getIndexOf","lineLength","isIPosition","hasChanged","maxCharacter","host","foreignModuleFactory","_host","_models","_foreignModuleFactory","_foreignModule","all","keys","EOL","strURL","onEvents","originalUrl","modifiedUrl","ignoreTrimWhitespace","_getModel","getLinesContent","diffComputer","identical","_modelsAreIdentical","originalLineCount","modifiedLineCount","modelUrl","edits","lastEol","sort","compareRangesUsingStarts","aRng","bRng","getValueInRange","_diffLimit","editOffset","offsetAt","lift","positionAt","newEdit","modelUrls","leadingWord","wordDef","wordDefFlags","sw","wordDefRegExp","seen","outer","_suggestionsLimit","duration","getLineWords","array","selectionText","wordRange","getWordAtPosition","navigateValueSet","createData","foreignHostMethods","fhr","foreignHost","ctx","getMirrorModels","_getModels","monaco","initialized","foreignModule","simpleWorker","onmessage"],"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","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _a;\nconst LANGUAGE_DEFAULT = 'en';\nlet _isWindows = false;\nlet _isMacintosh = false;\nlet _isLinux = false;\nlet _isLinuxSnap = false;\nlet _isNative = false;\nlet _isWeb = false;\nlet _isIOS = false;\nlet _locale = undefined;\nlet _language = LANGUAGE_DEFAULT;\nlet _translationsConfigFile = undefined;\nlet _userAgent = undefined;\nexport const globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});\nlet nodeProcess = undefined;\nif (typeof globals.vscode !== 'undefined' && typeof globals.vscode.process !== 'undefined') {\n    // Native environment (sandboxed)\n    nodeProcess = globals.vscode.process;\n}\nelse if (typeof process !== 'undefined') {\n    // Native environment (non-sandboxed)\n    nodeProcess = process;\n}\nconst isElectronRenderer = typeof ((_a = nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.versions) === null || _a === void 0 ? void 0 : _a.electron) === 'string' && nodeProcess.type === 'renderer';\n// Web environment\nif (typeof navigator === 'object' && !isElectronRenderer) {\n    _userAgent = navigator.userAgent;\n    _isWindows = _userAgent.indexOf('Windows') >= 0;\n    _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;\n    _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;\n    _isLinux = _userAgent.indexOf('Linux') >= 0;\n    _isWeb = true;\n    _locale = navigator.language;\n    _language = _locale;\n}\n// Native environment\nelse if (typeof nodeProcess === 'object') {\n    _isWindows = (nodeProcess.platform === 'win32');\n    _isMacintosh = (nodeProcess.platform === 'darwin');\n    _isLinux = (nodeProcess.platform === 'linux');\n    _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];\n    _locale = LANGUAGE_DEFAULT;\n    _language = LANGUAGE_DEFAULT;\n    const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];\n    if (rawNlsConfig) {\n        try {\n            const nlsConfig = JSON.parse(rawNlsConfig);\n            const resolved = nlsConfig.availableLanguages['*'];\n            _locale = nlsConfig.locale;\n            // VSCode's default language is 'en'\n            _language = resolved ? resolved : LANGUAGE_DEFAULT;\n            _translationsConfigFile = nlsConfig._translationsConfigFile;\n        }\n        catch (e) {\n        }\n    }\n    _isNative = true;\n}\n// Unknown environment\nelse {\n    console.error('Unable to resolve platform.');\n}\nlet _platform = 0 /* Web */;\nif (_isMacintosh) {\n    _platform = 1 /* Mac */;\n}\nelse if (_isWindows) {\n    _platform = 3 /* Windows */;\n}\nelse if (_isLinux) {\n    _platform = 2 /* Linux */;\n}\nexport const isWindows = _isWindows;\nexport const isMacintosh = _isMacintosh;\nexport const isLinux = _isLinux;\nexport const isNative = _isNative;\nexport const isWeb = _isWeb;\nexport const isIOS = _isIOS;\nexport const userAgent = _userAgent;\nexport const setImmediate = (function defineSetImmediate() {\n    if (globals.setImmediate) {\n        return globals.setImmediate.bind(globals);\n    }\n    if (typeof globals.postMessage === 'function' && !globals.importScripts) {\n        let pending = [];\n        globals.addEventListener('message', (e) => {\n            if (e.data && e.data.vscodeSetImmediateId) {\n                for (let i = 0, len = pending.length; i < len; i++) {\n                    const candidate = pending[i];\n                    if (candidate.id === e.data.vscodeSetImmediateId) {\n                        pending.splice(i, 1);\n                        candidate.callback();\n                        return;\n                    }\n                }\n            }\n        });\n        let lastId = 0;\n        return (callback) => {\n            const myId = ++lastId;\n            pending.push({\n                id: myId,\n                callback: callback\n            });\n            globals.postMessage({ vscodeSetImmediateId: myId }, '*');\n        };\n    }\n    if (typeof (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.nextTick) === 'function') {\n        return nodeProcess.nextTick.bind(nodeProcess);\n    }\n    const _promise = Promise.resolve();\n    return (callback) => _promise.then(callback);\n})();\nexport const OS = (_isMacintosh || _isIOS ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));\nlet _isLittleEndian = true;\nlet _isLittleEndianComputed = false;\nexport function isLittleEndian() {\n    if (!_isLittleEndianComputed) {\n        _isLittleEndianComputed = true;\n        const test = new Uint8Array(2);\n        test[0] = 1;\n        test[1] = 2;\n        const view = new Uint16Array(test.buffer);\n        _isLittleEndian = (view[0] === (2 << 8) + 1);\n    }\n    return _isLittleEndian;\n}\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","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { globals, isMacintosh, isWindows, setImmediate } from './platform.js';\nlet safeProcess;\n// Native sandbox environment\nif (typeof globals.vscode !== 'undefined' && typeof globals.vscode.process !== 'undefined') {\n    const sandboxProcess = globals.vscode.process;\n    safeProcess = {\n        get platform() { return sandboxProcess.platform; },\n        get arch() { return sandboxProcess.arch; },\n        get env() { return sandboxProcess.env; },\n        cwd() { return sandboxProcess.cwd(); },\n        nextTick(callback) { return setImmediate(callback); }\n    };\n}\n// Native node.js environment\nelse if (typeof process !== 'undefined') {\n    safeProcess = {\n        get platform() { return process.platform; },\n        get arch() { return process.arch; },\n        get env() { return process.env; },\n        cwd() { return process.env['VSCODE_CWD'] || process.cwd(); },\n        nextTick(callback) { return process.nextTick(callback); }\n    };\n}\n// Web environment\nelse {\n    safeProcess = {\n        // Supported\n        get platform() { return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux'; },\n        get arch() { return undefined; /* arch is undefined in web */ },\n        nextTick(callback) { return setImmediate(callback); },\n        // Unsupported\n        get env() { return {}; },\n        cwd() { return '/'; }\n    };\n}\n/**\n * Provides safe access to the `cwd` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `/`.\n */\nexport const cwd = safeProcess.cwd;\n/**\n * Provides safe access to the `env` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `{}`.\n */\nexport const env = safeProcess.env;\n/**\n * Provides safe access to the `platform` property in node.js, sandboxed or web\n * environments.\n */\nexport const platform = safeProcess.platform;\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","// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nexport class ErrorHandler {\n    constructor() {\n        this.listeners = [];\n        this.unexpectedErrorHandler = function (e) {\n            setTimeout(() => {\n                if (e.stack) {\n                    throw new Error(e.message + '\\n\\n' + e.stack);\n                }\n                throw e;\n            }, 0);\n        };\n    }\n    emit(e) {\n        this.listeners.forEach((listener) => {\n            listener(e);\n        });\n    }\n    onUnexpectedError(e) {\n        this.unexpectedErrorHandler(e);\n        this.emit(e);\n    }\n    // For external errors, we don't want the listeners to be called\n    onUnexpectedExternalError(e) {\n        this.unexpectedErrorHandler(e);\n    }\n}\nexport const errorHandler = new ErrorHandler();\nexport function onUnexpectedError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedError(e);\n    }\n    return undefined;\n}\nexport function onUnexpectedExternalError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedExternalError(e);\n    }\n    return undefined;\n}\nexport function transformErrorForSerialization(error) {\n    if (error instanceof Error) {\n        let { name, message } = error;\n        const stack = error.stacktrace || error.stack;\n        return {\n            $isError: true,\n            name,\n            message,\n            stack\n        };\n    }\n    // return as is\n    return error;\n}\nconst canceledName = 'Canceled';\n/**\n * Checks if the given error is a promise in canceled state\n */\nexport function isPromiseCanceledError(error) {\n    return error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n/**\n * Returns an error that signals cancellation.\n */\nexport function canceled() {\n    const error = new Error(canceledName);\n    error.name = error.message;\n    return error;\n}\nexport function illegalArgument(name) {\n    if (name) {\n        return new Error(`Illegal argument: ${name}`);\n    }\n    else {\n        return new Error('Illegal argument');\n    }\n}\nexport function illegalState(name) {\n    if (name) {\n        return new Error(`Illegal state: ${name}`);\n    }\n    else {\n        return new Error('Illegal state');\n    }\n}\nexport class NotSupportedError extends Error {\n    constructor(message) {\n        super('NotSupported');\n        if (message) {\n            this.message = message;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function once(fn) {\n    const _this = this;\n    let didCall = false;\n    let result;\n    return function () {\n        if (didCall) {\n            return result;\n        }\n        didCall = true;\n        result = fn.apply(_this, arguments);\n        return result;\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var Iterable;\n(function (Iterable) {\n    function is(thing) {\n        return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';\n    }\n    Iterable.is = is;\n    const _empty = Object.freeze([]);\n    function empty() {\n        return _empty;\n    }\n    Iterable.empty = empty;\n    function* single(element) {\n        yield element;\n    }\n    Iterable.single = single;\n    function from(iterable) {\n        return iterable || _empty;\n    }\n    Iterable.from = from;\n    function isEmpty(iterable) {\n        return !iterable || iterable[Symbol.iterator]().next().done === true;\n    }\n    Iterable.isEmpty = isEmpty;\n    function first(iterable) {\n        return iterable[Symbol.iterator]().next().value;\n    }\n    Iterable.first = first;\n    function some(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    Iterable.some = some;\n    function find(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                return element;\n            }\n        }\n        return undefined;\n    }\n    Iterable.find = find;\n    function* filter(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                yield element;\n            }\n        }\n    }\n    Iterable.filter = filter;\n    function* map(iterable, fn) {\n        let index = 0;\n        for (const element of iterable) {\n            yield fn(element, index++);\n        }\n    }\n    Iterable.map = map;\n    function* concat(...iterables) {\n        for (const iterable of iterables) {\n            for (const element of iterable) {\n                yield element;\n            }\n        }\n    }\n    Iterable.concat = concat;\n    function* concatNested(iterables) {\n        for (const iterable of iterables) {\n            for (const element of iterable) {\n                yield element;\n            }\n        }\n    }\n    Iterable.concatNested = concatNested;\n    function reduce(iterable, reducer, initialValue) {\n        let value = initialValue;\n        for (const element of iterable) {\n            value = reducer(value, element);\n        }\n        return value;\n    }\n    Iterable.reduce = reduce;\n    /**\n     * Returns an iterable slice of the array, with the same semantics as `array.slice()`.\n     */\n    function* slice(arr, from, to = arr.length) {\n        if (from < 0) {\n            from += arr.length;\n        }\n        if (to < 0) {\n            to += arr.length;\n        }\n        else if (to > arr.length) {\n            to = arr.length;\n        }\n        for (; from < to; from++) {\n            yield arr[from];\n        }\n    }\n    Iterable.slice = slice;\n    /**\n     * Consumes `atMost` elements from iterable and returns the consumed elements,\n     * and an iterable for the rest of the elements.\n     */\n    function consume(iterable, atMost = Number.POSITIVE_INFINITY) {\n        const consumed = [];\n        if (atMost === 0) {\n            return [consumed, iterable];\n        }\n        const iterator = iterable[Symbol.iterator]();\n        for (let i = 0; i < atMost; i++) {\n            const next = iterator.next();\n            if (next.done) {\n                return [consumed, Iterable.empty()];\n            }\n            consumed.push(next.value);\n        }\n        return [consumed, { [Symbol.iterator]() { return iterator; } }];\n    }\n    Iterable.consume = consume;\n    /**\n     * Returns whether the iterables are the same length and all items are\n     * equal using the comparator function.\n     */\n    function equals(a, b, comparator = (at, bt) => at === bt) {\n        const ai = a[Symbol.iterator]();\n        const bi = b[Symbol.iterator]();\n        while (true) {\n            const an = ai.next();\n            const bn = bi.next();\n            if (an.done !== bn.done) {\n                return false;\n            }\n            else if (an.done) {\n                return true;\n            }\n            else if (!comparator(an.value, bn.value)) {\n                return false;\n            }\n        }\n    }\n    Iterable.equals = equals;\n})(Iterable || (Iterable = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { once } from './functional.js';\nimport { Iterable } from './iterator.js';\n/**\n * Enables logging of potentially leaked disposables.\n *\n * A disposable is considered leaked if it is not disposed or not registered as the child of\n * another disposable. This tracking is very simple an only works for classes that either\n * extend Disposable or use a DisposableStore. This means there are a lot of false positives.\n */\nconst TRACK_DISPOSABLES = false;\nlet disposableTracker = null;\nexport function setDisposableTracker(tracker) {\n    disposableTracker = tracker;\n}\nif (TRACK_DISPOSABLES) {\n    const __is_disposable_tracked__ = '__is_disposable_tracked__';\n    setDisposableTracker(new class {\n        trackDisposable(x) {\n            const stack = new Error('Potentially leaked disposable').stack;\n            setTimeout(() => {\n                if (!x[__is_disposable_tracked__]) {\n                    console.log(stack);\n                }\n            }, 3000);\n        }\n        setParent(child, parent) {\n            if (child && child !== Disposable.None) {\n                try {\n                    child[__is_disposable_tracked__] = true;\n                }\n                catch (_a) {\n                    // noop\n                }\n            }\n        }\n        markAsDisposed(disposable) {\n            if (disposable && disposable !== Disposable.None) {\n                try {\n                    disposable[__is_disposable_tracked__] = true;\n                }\n                catch (_a) {\n                    // noop\n                }\n            }\n        }\n        markAsSingleton(disposable) { }\n    });\n}\nfunction trackDisposable(x) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.trackDisposable(x);\n    return x;\n}\nfunction markAsDisposed(disposable) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsDisposed(disposable);\n}\nfunction setParentOfDisposable(child, parent) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.setParent(child, parent);\n}\nfunction setParentOfDisposables(children, parent) {\n    if (!disposableTracker) {\n        return;\n    }\n    for (const child of children) {\n        disposableTracker.setParent(child, parent);\n    }\n}\n/**\n * Indicates that the given object is a singleton which does not need to be disposed.\n*/\nexport function markAsSingleton(singleton) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsSingleton(singleton);\n    return singleton;\n}\nexport class MultiDisposeError extends Error {\n    constructor(errors) {\n        super(`Encountered errors while disposing of store. Errors: [${errors.join(', ')}]`);\n        this.errors = errors;\n    }\n}\nexport function isDisposable(thing) {\n    return typeof thing.dispose === 'function' && thing.dispose.length === 0;\n}\nexport function dispose(arg) {\n    if (Iterable.is(arg)) {\n        let errors = [];\n        for (const d of arg) {\n            if (d) {\n                try {\n                    d.dispose();\n                }\n                catch (e) {\n                    errors.push(e);\n                }\n            }\n        }\n        if (errors.length === 1) {\n            throw errors[0];\n        }\n        else if (errors.length > 1) {\n            throw new MultiDisposeError(errors);\n        }\n        return Array.isArray(arg) ? [] : arg;\n    }\n    else if (arg) {\n        arg.dispose();\n        return arg;\n    }\n}\nexport function combinedDisposable(...disposables) {\n    const parent = toDisposable(() => dispose(disposables));\n    setParentOfDisposables(disposables, parent);\n    return parent;\n}\nexport function toDisposable(fn) {\n    const self = trackDisposable({\n        dispose: once(() => {\n            markAsDisposed(self);\n            fn();\n        })\n    });\n    return self;\n}\nexport class DisposableStore {\n    constructor() {\n        this._toDispose = new Set();\n        this._isDisposed = false;\n        trackDisposable(this);\n    }\n    /**\n     * Dispose of all registered disposables and mark this object as disposed.\n     *\n     * Any future disposables added to this object will be disposed of on `add`.\n     */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        markAsDisposed(this);\n        this._isDisposed = true;\n        this.clear();\n    }\n    /**\n     * Dispose of all registered disposables but do not mark this object as disposed.\n     */\n    clear() {\n        try {\n            dispose(this._toDispose.values());\n        }\n        finally {\n            this._toDispose.clear();\n        }\n    }\n    add(o) {\n        if (!o) {\n            return o;\n        }\n        if (o === this) {\n            throw new Error('Cannot register a disposable on itself!');\n        }\n        setParentOfDisposable(o, this);\n        if (this._isDisposed) {\n            if (!DisposableStore.DISABLE_DISPOSED_WARNING) {\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);\n            }\n        }\n        else {\n            this._toDispose.add(o);\n        }\n        return o;\n    }\n}\nDisposableStore.DISABLE_DISPOSED_WARNING = false;\nexport class Disposable {\n    constructor() {\n        this._store = new DisposableStore();\n        trackDisposable(this);\n        setParentOfDisposable(this._store, this);\n    }\n    dispose() {\n        markAsDisposed(this);\n        this._store.dispose();\n    }\n    _register(o) {\n        if (o === this) {\n            throw new Error('Cannot register a disposable on itself!');\n        }\n        return this._store.add(o);\n    }\n}\nDisposable.None = Object.freeze({ dispose() { } });\n/**\n * Manages the lifecycle of a disposable value that may be changed.\n *\n * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can\n * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.\n */\nexport class MutableDisposable {\n    constructor() {\n        this._isDisposed = false;\n        trackDisposable(this);\n    }\n    get value() {\n        return this._isDisposed ? undefined : this._value;\n    }\n    set value(value) {\n        var _a;\n        if (this._isDisposed || value === this._value) {\n            return;\n        }\n        (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n        if (value) {\n            setParentOfDisposable(value, this);\n        }\n        this._value = value;\n    }\n    clear() {\n        this.value = undefined;\n    }\n    dispose() {\n        var _a;\n        this._isDisposed = true;\n        markAsDisposed(this);\n        (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n        this._value = undefined;\n    }\n    /**\n     * Clears the value, but does not dispose it.\n     * The old value is returned.\n    */\n    clearAndLeak() {\n        const oldValue = this._value;\n        this._value = undefined;\n        if (oldValue) {\n            setParentOfDisposable(oldValue, null);\n        }\n        return oldValue;\n    }\n}\nexport class ImmortalReference {\n    constructor(object) {\n        this.object = object;\n    }\n    dispose() { }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass Node {\n    constructor(element) {\n        this.element = element;\n        this.next = Node.Undefined;\n        this.prev = Node.Undefined;\n    }\n}\nNode.Undefined = new Node(undefined);\nexport class LinkedList {\n    constructor() {\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    }\n    get size() {\n        return this._size;\n    }\n    isEmpty() {\n        return this._first === Node.Undefined;\n    }\n    clear() {\n        let node = this._first;\n        while (node !== Node.Undefined) {\n            const next = node.next;\n            node.prev = Node.Undefined;\n            node.next = Node.Undefined;\n            node = next;\n        }\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    }\n    unshift(element) {\n        return this._insert(element, false);\n    }\n    push(element) {\n        return this._insert(element, true);\n    }\n    _insert(element, atTheEnd) {\n        const newNode = new Node(element);\n        if (this._first === Node.Undefined) {\n            this._first = newNode;\n            this._last = newNode;\n        }\n        else if (atTheEnd) {\n            // push\n            const oldLast = this._last;\n            this._last = newNode;\n            newNode.prev = oldLast;\n            oldLast.next = newNode;\n        }\n        else {\n            // unshift\n            const oldFirst = this._first;\n            this._first = newNode;\n            newNode.next = oldFirst;\n            oldFirst.prev = newNode;\n        }\n        this._size += 1;\n        let didRemove = false;\n        return () => {\n            if (!didRemove) {\n                didRemove = true;\n                this._remove(newNode);\n            }\n        };\n    }\n    shift() {\n        if (this._first === Node.Undefined) {\n            return undefined;\n        }\n        else {\n            const res = this._first.element;\n            this._remove(this._first);\n            return res;\n        }\n    }\n    pop() {\n        if (this._last === Node.Undefined) {\n            return undefined;\n        }\n        else {\n            const res = this._last.element;\n            this._remove(this._last);\n            return res;\n        }\n    }\n    _remove(node) {\n        if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {\n            // middle\n            const anchor = node.prev;\n            anchor.next = node.next;\n            node.next.prev = anchor;\n        }\n        else if (node.prev === Node.Undefined && node.next === Node.Undefined) {\n            // only node\n            this._first = Node.Undefined;\n            this._last = Node.Undefined;\n        }\n        else if (node.next === Node.Undefined) {\n            // last\n            this._last = this._last.prev;\n            this._last.next = Node.Undefined;\n        }\n        else if (node.prev === Node.Undefined) {\n            // first\n            this._first = this._first.next;\n            this._first.prev = Node.Undefined;\n        }\n        // done\n        this._size -= 1;\n    }\n    *[Symbol.iterator]() {\n        let node = this._first;\n        while (node !== Node.Undefined) {\n            yield node.element;\n            node = node.next;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { globals } from './platform.js';\nconst hasPerformanceNow = (globals.performance && typeof globals.performance.now === 'function');\nexport class StopWatch {\n    constructor(highResolution) {\n        this._highResolution = hasPerformanceNow && highResolution;\n        this._startTime = this._now();\n        this._stopTime = -1;\n    }\n    static create(highResolution = true) {\n        return new StopWatch(highResolution);\n    }\n    stop() {\n        this._stopTime = this._now();\n    }\n    elapsed() {\n        if (this._stopTime !== -1) {\n            return this._stopTime - this._startTime;\n        }\n        return this._now() - this._startTime;\n    }\n    _now() {\n        return this._highResolution ? globals.performance.now() : Date.now();\n    }\n}\n","import { onUnexpectedError } from './errors.js';\nimport { combinedDisposable, Disposable, DisposableStore, toDisposable } from './lifecycle.js';\nimport { LinkedList } from './linkedList.js';\nimport { StopWatch } from './stopwatch.js';\nexport var Event;\n(function (Event) {\n    Event.None = () => Disposable.None;\n    /**\n     * Given an event, returns another event which only fires once.\n     */\n    function once(event) {\n        return (listener, thisArgs = null, disposables) => {\n            // we need this, in case the event fires during the listener call\n            let didFire = false;\n            let result;\n            result = event(e => {\n                if (didFire) {\n                    return;\n                }\n                else if (result) {\n                    result.dispose();\n                }\n                else {\n                    didFire = true;\n                }\n                return listener.call(thisArgs, e);\n            }, null, disposables);\n            if (didFire) {\n                result.dispose();\n            }\n            return result;\n        };\n    }\n    Event.once = once;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function map(event, map) {\n        return snapshot((listener, thisArgs = null, disposables) => event(i => listener.call(thisArgs, map(i)), null, disposables));\n    }\n    Event.map = map;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function forEach(event, each) {\n        return snapshot((listener, thisArgs = null, disposables) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables));\n    }\n    Event.forEach = forEach;\n    function filter(event, filter) {\n        return snapshot((listener, thisArgs = null, disposables) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables));\n    }\n    Event.filter = filter;\n    /**\n     * Given an event, returns the same event but typed as `Event<void>`.\n     */\n    function signal(event) {\n        return event;\n    }\n    Event.signal = signal;\n    function any(...events) {\n        return (listener, thisArgs = null, disposables) => combinedDisposable(...events.map(event => event(e => listener.call(thisArgs, e), null, disposables)));\n    }\n    Event.any = any;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function reduce(event, merge, initial) {\n        let output = initial;\n        return map(event, e => {\n            output = merge(output, e);\n            return output;\n        });\n    }\n    Event.reduce = reduce;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function snapshot(event) {\n        let listener;\n        const emitter = new Emitter({\n            onFirstListenerAdd() {\n                listener = event(emitter.fire, emitter);\n            },\n            onLastListenerRemove() {\n                listener.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function debounce(event, merge, delay = 100, leading = false, leakWarningThreshold) {\n        let subscription;\n        let output = undefined;\n        let handle = undefined;\n        let numDebouncedCalls = 0;\n        const emitter = new Emitter({\n            leakWarningThreshold,\n            onFirstListenerAdd() {\n                subscription = event(cur => {\n                    numDebouncedCalls++;\n                    output = merge(output, cur);\n                    if (leading && !handle) {\n                        emitter.fire(output);\n                        output = undefined;\n                    }\n                    clearTimeout(handle);\n                    handle = setTimeout(() => {\n                        const _output = output;\n                        output = undefined;\n                        handle = undefined;\n                        if (!leading || numDebouncedCalls > 1) {\n                            emitter.fire(_output);\n                        }\n                        numDebouncedCalls = 0;\n                    }, delay);\n                });\n            },\n            onLastListenerRemove() {\n                subscription.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.debounce = debounce;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function latch(event, equals = (a, b) => a === b) {\n        let firstCall = true;\n        let cache;\n        return filter(event, value => {\n            const shouldEmit = firstCall || !equals(value, cache);\n            firstCall = false;\n            cache = value;\n            return shouldEmit;\n        });\n    }\n    Event.latch = latch;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function split(event, isT) {\n        return [\n            Event.filter(event, isT),\n            Event.filter(event, e => !isT(e)),\n        ];\n    }\n    Event.split = split;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function buffer(event, nextTick = false, _buffer = []) {\n        let buffer = _buffer.slice();\n        let listener = event(e => {\n            if (buffer) {\n                buffer.push(e);\n            }\n            else {\n                emitter.fire(e);\n            }\n        });\n        const flush = () => {\n            if (buffer) {\n                buffer.forEach(e => emitter.fire(e));\n            }\n            buffer = null;\n        };\n        const emitter = new Emitter({\n            onFirstListenerAdd() {\n                if (!listener) {\n                    listener = event(e => emitter.fire(e));\n                }\n            },\n            onFirstListenerDidAdd() {\n                if (buffer) {\n                    if (nextTick) {\n                        setTimeout(flush);\n                    }\n                    else {\n                        flush();\n                    }\n                }\n            },\n            onLastListenerRemove() {\n                if (listener) {\n                    listener.dispose();\n                }\n                listener = null;\n            }\n        });\n        return emitter.event;\n    }\n    Event.buffer = buffer;\n    class ChainableEvent {\n        constructor(event) {\n            this.event = event;\n        }\n        map(fn) {\n            return new ChainableEvent(map(this.event, fn));\n        }\n        forEach(fn) {\n            return new ChainableEvent(forEach(this.event, fn));\n        }\n        filter(fn) {\n            return new ChainableEvent(filter(this.event, fn));\n        }\n        reduce(merge, initial) {\n            return new ChainableEvent(reduce(this.event, merge, initial));\n        }\n        latch() {\n            return new ChainableEvent(latch(this.event));\n        }\n        debounce(merge, delay = 100, leading = false, leakWarningThreshold) {\n            return new ChainableEvent(debounce(this.event, merge, delay, leading, leakWarningThreshold));\n        }\n        on(listener, thisArgs, disposables) {\n            return this.event(listener, thisArgs, disposables);\n        }\n        once(listener, thisArgs, disposables) {\n            return once(this.event)(listener, thisArgs, disposables);\n        }\n    }\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function chain(event) {\n        return new ChainableEvent(event);\n    }\n    Event.chain = chain;\n    function fromNodeEventEmitter(emitter, eventName, map = id => id) {\n        const fn = (...args) => result.fire(map(...args));\n        const onFirstListenerAdd = () => emitter.on(eventName, fn);\n        const onLastListenerRemove = () => emitter.removeListener(eventName, fn);\n        const result = new Emitter({ onFirstListenerAdd, onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromNodeEventEmitter = fromNodeEventEmitter;\n    function fromDOMEventEmitter(emitter, eventName, map = id => id) {\n        const fn = (...args) => result.fire(map(...args));\n        const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn);\n        const onLastListenerRemove = () => emitter.removeEventListener(eventName, fn);\n        const result = new Emitter({ onFirstListenerAdd, onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromDOMEventEmitter = fromDOMEventEmitter;\n    function toPromise(event) {\n        return new Promise(resolve => once(event)(resolve));\n    }\n    Event.toPromise = toPromise;\n})(Event || (Event = {}));\nclass EventProfiling {\n    constructor(name) {\n        this._listenerCount = 0;\n        this._invocationCount = 0;\n        this._elapsedOverall = 0;\n        this._name = `${name}_${EventProfiling._idPool++}`;\n    }\n    start(listenerCount) {\n        this._stopWatch = new StopWatch(true);\n        this._listenerCount = listenerCount;\n    }\n    stop() {\n        if (this._stopWatch) {\n            const elapsed = this._stopWatch.elapsed();\n            this._elapsedOverall += elapsed;\n            this._invocationCount += 1;\n            console.info(`did FIRE ${this._name}: elapsed_ms: ${elapsed.toFixed(5)}, listener: ${this._listenerCount} (elapsed_overall: ${this._elapsedOverall.toFixed(2)}, invocations: ${this._invocationCount})`);\n            this._stopWatch = undefined;\n        }\n    }\n}\nEventProfiling._idPool = 0;\nlet _globalLeakWarningThreshold = -1;\nclass LeakageMonitor {\n    constructor(customThreshold, name = Math.random().toString(18).slice(2, 5)) {\n        this.customThreshold = customThreshold;\n        this.name = name;\n        this._warnCountdown = 0;\n    }\n    dispose() {\n        if (this._stacks) {\n            this._stacks.clear();\n        }\n    }\n    check(listenerCount) {\n        let threshold = _globalLeakWarningThreshold;\n        if (typeof this.customThreshold === 'number') {\n            threshold = this.customThreshold;\n        }\n        if (threshold <= 0 || listenerCount < threshold) {\n            return undefined;\n        }\n        if (!this._stacks) {\n            this._stacks = new Map();\n        }\n        const stack = new Error().stack.split('\\n').slice(3).join('\\n');\n        const count = (this._stacks.get(stack) || 0);\n        this._stacks.set(stack, count + 1);\n        this._warnCountdown -= 1;\n        if (this._warnCountdown <= 0) {\n            // only warn on first exceed and then every time the limit\n            // is exceeded by 50% again\n            this._warnCountdown = threshold * 0.5;\n            // find most frequent listener and print warning\n            let topStack;\n            let topCount = 0;\n            for (const [stack, count] of this._stacks) {\n                if (!topStack || topCount < count) {\n                    topStack = stack;\n                    topCount = count;\n                }\n            }\n            console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`);\n            console.warn(topStack);\n        }\n        return () => {\n            const count = (this._stacks.get(stack) || 0);\n            this._stacks.set(stack, count - 1);\n        };\n    }\n}\n/**\n * The Emitter can be used to expose an Event to the public\n * to fire it from the insides.\n * Sample:\n    class Document {\n\n        private readonly _onDidChange = new Emitter<(value:string)=>any>();\n\n        public onDidChange = this._onDidChange.event;\n\n        // getter-style\n        // get onDidChange(): Event<(value:string)=>any> {\n        // \treturn this._onDidChange.event;\n        // }\n\n        private _doIt() {\n            //...\n            this._onDidChange.fire(value);\n        }\n    }\n */\nexport class Emitter {\n    constructor(options) {\n        var _a;\n        this._disposed = false;\n        this._options = options;\n        this._leakageMon = _globalLeakWarningThreshold > 0 ? new LeakageMonitor(this._options && this._options.leakWarningThreshold) : undefined;\n        this._perfMon = ((_a = this._options) === null || _a === void 0 ? void 0 : _a._profName) ? new EventProfiling(this._options._profName) : undefined;\n    }\n    /**\n     * For the public to allow to subscribe\n     * to events from this Emitter\n     */\n    get event() {\n        if (!this._event) {\n            this._event = (listener, thisArgs, disposables) => {\n                var _a;\n                if (!this._listeners) {\n                    this._listeners = new LinkedList();\n                }\n                const firstListener = this._listeners.isEmpty();\n                if (firstListener && this._options && this._options.onFirstListenerAdd) {\n                    this._options.onFirstListenerAdd(this);\n                }\n                const remove = this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\n                if (firstListener && this._options && this._options.onFirstListenerDidAdd) {\n                    this._options.onFirstListenerDidAdd(this);\n                }\n                if (this._options && this._options.onListenerDidAdd) {\n                    this._options.onListenerDidAdd(this, listener, thisArgs);\n                }\n                // check and record this emitter for potential leakage\n                const removeMonitor = (_a = this._leakageMon) === null || _a === void 0 ? void 0 : _a.check(this._listeners.size);\n                const result = toDisposable(() => {\n                    if (removeMonitor) {\n                        removeMonitor();\n                    }\n                    if (!this._disposed) {\n                        remove();\n                        if (this._options && this._options.onLastListenerRemove) {\n                            const hasListeners = (this._listeners && !this._listeners.isEmpty());\n                            if (!hasListeners) {\n                                this._options.onLastListenerRemove(this);\n                            }\n                        }\n                    }\n                });\n                if (disposables instanceof DisposableStore) {\n                    disposables.add(result);\n                }\n                else if (Array.isArray(disposables)) {\n                    disposables.push(result);\n                }\n                return result;\n            };\n        }\n        return this._event;\n    }\n    /**\n     * To be kept private to fire an event to\n     * subscribers\n     */\n    fire(event) {\n        var _a, _b;\n        if (this._listeners) {\n            // put all [listener,event]-pairs into delivery queue\n            // then emit all event. an inner/nested event might be\n            // the driver of this\n            if (!this._deliveryQueue) {\n                this._deliveryQueue = new LinkedList();\n            }\n            for (let listener of this._listeners) {\n                this._deliveryQueue.push([listener, event]);\n            }\n            // start/stop performance insight collection\n            (_a = this._perfMon) === null || _a === void 0 ? void 0 : _a.start(this._deliveryQueue.size);\n            while (this._deliveryQueue.size > 0) {\n                const [listener, event] = this._deliveryQueue.shift();\n                try {\n                    if (typeof listener === 'function') {\n                        listener.call(undefined, event);\n                    }\n                    else {\n                        listener[0].call(listener[1], event);\n                    }\n                }\n                catch (e) {\n                    onUnexpectedError(e);\n                }\n            }\n            (_b = this._perfMon) === null || _b === void 0 ? void 0 : _b.stop();\n        }\n    }\n    dispose() {\n        var _a, _b, _c, _d, _e;\n        if (!this._disposed) {\n            this._disposed = true;\n            (_a = this._listeners) === null || _a === void 0 ? void 0 : _a.clear();\n            (_b = this._deliveryQueue) === null || _b === void 0 ? void 0 : _b.clear();\n            (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onLastListenerRemove) === null || _d === void 0 ? void 0 : _d.call(_c);\n            (_e = this._leakageMon) === null || _e === void 0 ? void 0 : _e.dispose();\n        }\n    }\n}\nexport class PauseableEmitter extends Emitter {\n    constructor(options) {\n        super(options);\n        this._isPaused = 0;\n        this._eventQueue = new LinkedList();\n        this._mergeFn = options === null || options === void 0 ? void 0 : options.merge;\n    }\n    pause() {\n        this._isPaused++;\n    }\n    resume() {\n        if (this._isPaused !== 0 && --this._isPaused === 0) {\n            if (this._mergeFn) {\n                // use the merge function to create a single composite\n                // event. make a copy in case firing pauses this emitter\n                const events = Array.from(this._eventQueue);\n                this._eventQueue.clear();\n                super.fire(this._mergeFn(events));\n            }\n            else {\n                // no merging, fire each event individually and test\n                // that this emitter isn't paused halfway through\n                while (!this._isPaused && this._eventQueue.size !== 0) {\n                    super.fire(this._eventQueue.shift());\n                }\n            }\n        }\n    }\n    fire(event) {\n        if (this._listeners) {\n            if (this._isPaused !== 0) {\n                this._eventQueue.push(event);\n            }\n            else {\n                super.fire(event);\n            }\n        }\n    }\n}\nexport class DebounceEmitter extends PauseableEmitter {\n    constructor(options) {\n        var _a;\n        super(options);\n        this._delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 100;\n    }\n    fire(event) {\n        if (!this._handle) {\n            this.pause();\n            this._handle = setTimeout(() => {\n                this._handle = undefined;\n                this.resume();\n            }, this._delay);\n        }\n        super.fire(event);\n    }\n}\n/**\n * The EventBufferer is useful in situations in which you want\n * to delay firing your events during some code.\n * You can wrap that code and be sure that the event will not\n * be fired during that wrap.\n *\n * ```\n * const emitter: Emitter;\n * const delayer = new EventDelayer();\n * const delayedEvent = delayer.wrapEvent(emitter.event);\n *\n * delayedEvent(console.log);\n *\n * delayer.bufferEvents(() => {\n *   emitter.fire(); // event will not be fired yet\n * });\n *\n * // event will only be fired at this point\n * ```\n */\nexport class EventBufferer {\n    constructor() {\n        this.buffers = [];\n    }\n    wrapEvent(event) {\n        return (listener, thisArgs, disposables) => {\n            return event(i => {\n                const buffer = this.buffers[this.buffers.length - 1];\n                if (buffer) {\n                    buffer.push(() => listener.call(thisArgs, i));\n                }\n                else {\n                    listener.call(thisArgs, i);\n                }\n            }, undefined, disposables);\n        };\n    }\n    bufferEvents(fn) {\n        const buffer = [];\n        this.buffers.push(buffer);\n        const r = fn();\n        this.buffers.pop();\n        buffer.forEach(flush => flush());\n        return r;\n    }\n}\n/**\n * A Relay is an event forwarder which functions as a replugabble event pipe.\n * Once created, you can connect an input event to it and it will simply forward\n * events from that input event through its own `event` property. The `input`\n * can be changed at any point in time.\n */\nexport class Relay {\n    constructor() {\n        this.listening = false;\n        this.inputEvent = Event.None;\n        this.inputEventListener = Disposable.None;\n        this.emitter = new Emitter({\n            onFirstListenerDidAdd: () => {\n                this.listening = true;\n                this.inputEventListener = this.inputEvent(this.emitter.fire, this.emitter);\n            },\n            onLastListenerRemove: () => {\n                this.listening = false;\n                this.inputEventListener.dispose();\n            }\n        });\n        this.event = this.emitter.event;\n    }\n    set input(event) {\n        this.inputEvent = event;\n        if (this.listening) {\n            this.inputEventListener.dispose();\n            this.inputEventListener = event(this.emitter.fire, this.emitter);\n        }\n    }\n    dispose() {\n        this.inputEventListener.dispose();\n        this.emitter.dispose();\n    }\n}\n","/**\n * @returns whether the provided parameter is a JavaScript Array or not.\n */\nexport function isArray(array) {\n    return Array.isArray(array);\n}\n/**\n * @returns whether the provided parameter is a JavaScript String or not.\n */\nexport function isString(str) {\n    return (typeof str === 'string');\n}\n/**\n *\n * @returns whether the provided parameter is of type `object` but **not**\n *\t`null`, an `array`, a `regexp`, nor a `date`.\n */\nexport function isObject(obj) {\n    // The method can't do a type cast since there are type (like strings) which\n    // are subclasses of any put not positvely matched by the function. Hence type\n    // narrowing results in wrong results.\n    return typeof obj === 'object'\n        && obj !== null\n        && !Array.isArray(obj)\n        && !(obj instanceof RegExp)\n        && !(obj instanceof Date);\n}\n/**\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\n * @returns whether the provided parameter is a JavaScript Number or not.\n */\nexport function isNumber(obj) {\n    return (typeof obj === 'number' && !isNaN(obj));\n}\n/**\n * @returns whether the provided parameter is a JavaScript Boolean or not.\n */\nexport function isBoolean(obj) {\n    return (obj === true || obj === false);\n}\n/**\n * @returns whether the provided parameter is undefined.\n */\nexport function isUndefined(obj) {\n    return (typeof obj === 'undefined');\n}\n/**\n * @returns whether the provided parameter is defined.\n */\nexport function isDefined(arg) {\n    return !isUndefinedOrNull(arg);\n}\n/**\n * @returns whether the provided parameter is undefined or null.\n */\nexport function isUndefinedOrNull(obj) {\n    return (isUndefined(obj) || obj === null);\n}\nexport function assertType(condition, type) {\n    if (!condition) {\n        throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');\n    }\n}\n/**\n * Asserts that the argument passed in is neither undefined nor null.\n */\nexport function assertIsDefined(arg) {\n    if (isUndefinedOrNull(arg)) {\n        throw new Error('Assertion Failed: argument is undefined or null');\n    }\n    return arg;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Function or not.\n */\nexport function isFunction(obj) {\n    return (typeof obj === 'function');\n}\nexport function validateConstraints(args, constraints) {\n    const len = Math.min(args.length, constraints.length);\n    for (let i = 0; i < len; i++) {\n        validateConstraint(args[i], constraints[i]);\n    }\n}\nexport function validateConstraint(arg, constraint) {\n    if (isString(constraint)) {\n        if (typeof arg !== constraint) {\n            throw new Error(`argument does not match constraint: typeof ${constraint}`);\n        }\n    }\n    else if (isFunction(constraint)) {\n        try {\n            if (arg instanceof constraint) {\n                return;\n            }\n        }\n        catch (_a) {\n            // ignore\n        }\n        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\n            return;\n        }\n        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\n            return;\n        }\n        throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);\n    }\n}\nexport function getAllPropertyNames(obj) {\n    let res = [];\n    let proto = Object.getPrototypeOf(obj);\n    while (Object.prototype !== proto) {\n        res = res.concat(Object.getOwnPropertyNames(proto));\n        proto = Object.getPrototypeOf(proto);\n    }\n    return res;\n}\nexport function getAllMethodNames(obj) {\n    const methods = [];\n    for (const prop of getAllPropertyNames(obj)) {\n        if (typeof obj[prop] === 'function') {\n            methods.push(prop);\n        }\n    }\n    return methods;\n}\nexport function createProxyObject(methodNames, invoke) {\n    const createProxyMethod = (method) => {\n        return function () {\n            const args = Array.prototype.slice.call(arguments, 0);\n            return invoke(method, args);\n        };\n    };\n    let result = {};\n    for (const methodName of methodNames) {\n        result[methodName] = createProxyMethod(methodName);\n    }\n    return result;\n}\n/**\n * Converts null to undefined, passes all other values through.\n */\nexport function withNullAsUndefined(x) {\n    return x === null ? undefined : x;\n}\nexport function assertNever(value, message = 'Unreachable') {\n    throw new Error(message);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function isFalsyOrWhitespace(str) {\n    if (!str || typeof str !== 'string') {\n        return true;\n    }\n    return str.trim().length === 0;\n}\nconst _formatRegexp = /{(\\d+)}/g;\n/**\n * Helper to produce a string with a variable number of arguments. Insert variable segments\n * into the string using the {n} notation where N is the index of the argument following the string.\n * @param value string to which formatting is applied\n * @param args replacements for {n}-entries\n */\nexport function format(value, ...args) {\n    if (args.length === 0) {\n        return value;\n    }\n    return value.replace(_formatRegexp, function (match, group) {\n        const idx = parseInt(group, 10);\n        return isNaN(idx) || idx < 0 || idx >= args.length ?\n            match :\n            args[idx];\n    });\n}\n/**\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\n * being used e.g. in HTMLElement.innerHTML.\n */\nexport function escape(html) {\n    return html.replace(/[<>&]/g, function (match) {\n        switch (match) {\n            case '<': return '&lt;';\n            case '>': return '&gt;';\n            case '&': return '&amp;';\n            default: return match;\n        }\n    });\n}\n/**\n * Escapes regular expression characters in a given string\n */\nexport function escapeRegExpCharacters(value) {\n    return value.replace(/[\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)]/g, '\\\\$&');\n}\n/**\n * Removes all occurrences of needle from the beginning and end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim (default is a blank)\n */\nexport function trim(haystack, needle = ' ') {\n    const trimmed = ltrim(haystack, needle);\n    return rtrim(trimmed, needle);\n}\n/**\n * Removes all occurrences of needle from the beginning of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function ltrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    const needleLen = needle.length;\n    if (needleLen === 0 || haystack.length === 0) {\n        return haystack;\n    }\n    let offset = 0;\n    while (haystack.indexOf(needle, offset) === offset) {\n        offset = offset + needleLen;\n    }\n    return haystack.substring(offset);\n}\n/**\n * Removes all occurrences of needle from the end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function rtrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    const needleLen = needle.length, haystackLen = haystack.length;\n    if (needleLen === 0 || haystackLen === 0) {\n        return haystack;\n    }\n    let offset = haystackLen, idx = -1;\n    while (true) {\n        idx = haystack.lastIndexOf(needle, offset - 1);\n        if (idx === -1 || idx + needleLen !== offset) {\n            break;\n        }\n        if (idx === 0) {\n            return '';\n        }\n        offset = idx;\n    }\n    return haystack.substring(0, offset);\n}\nexport function convertSimple2RegExpPattern(pattern) {\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\nexport function stripWildcards(pattern) {\n    return pattern.replace(/\\*/g, '');\n}\nexport function createRegExp(searchString, isRegex, options = {}) {\n    if (!searchString) {\n        throw new Error('Cannot create regex from empty string');\n    }\n    if (!isRegex) {\n        searchString = escapeRegExpCharacters(searchString);\n    }\n    if (options.wholeWord) {\n        if (!/\\B/.test(searchString.charAt(0))) {\n            searchString = '\\\\b' + searchString;\n        }\n        if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n            searchString = searchString + '\\\\b';\n        }\n    }\n    let modifiers = '';\n    if (options.global) {\n        modifiers += 'g';\n    }\n    if (!options.matchCase) {\n        modifiers += 'i';\n    }\n    if (options.multiline) {\n        modifiers += 'm';\n    }\n    if (options.unicode) {\n        modifiers += 'u';\n    }\n    return new RegExp(searchString, modifiers);\n}\nexport function regExpLeadsToEndlessLoop(regexp) {\n    // Exit early if it's one of these special cases which are meant to match\n    // against an empty string\n    if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n        return false;\n    }\n    // We check against an empty string. If the regular expression doesn't advance\n    // (e.g. ends in an endless loop) it will match an empty string.\n    const match = regexp.exec('');\n    return !!(match && regexp.lastIndex === 0);\n}\nexport function regExpFlags(regexp) {\n    return (regexp.global ? 'g' : '')\n        + (regexp.ignoreCase ? 'i' : '')\n        + (regexp.multiline ? 'm' : '')\n        + (regexp /* standalone editor compilation */.unicode ? 'u' : '');\n}\nexport function splitLines(str) {\n    return str.split(/\\r\\n|\\r|\\n/);\n}\n/**\n * Returns first index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function firstNonWhitespaceIndex(str) {\n    for (let i = 0, len = str.length; i < len; i++) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\n/**\n * Returns the leading whitespace of the string.\n * If the string contains only whitespaces, returns entire string\n */\nexport function getLeadingWhitespace(str, start = 0, end = str.length) {\n    for (let i = start; i < end; i++) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return str.substring(start, i);\n        }\n    }\n    return str.substring(start, end);\n}\n/**\n * Returns last index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function lastNonWhitespaceIndex(str, startIndex = str.length - 1) {\n    for (let i = startIndex; i >= 0; i--) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\nexport function compare(a, b) {\n    if (a < b) {\n        return -1;\n    }\n    else if (a > b) {\n        return 1;\n    }\n    else {\n        return 0;\n    }\n}\nexport function compareSubstring(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n    for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n        let codeA = a.charCodeAt(aStart);\n        let codeB = b.charCodeAt(bStart);\n        if (codeA < codeB) {\n            return -1;\n        }\n        else if (codeA > codeB) {\n            return 1;\n        }\n    }\n    const aLen = aEnd - aStart;\n    const bLen = bEnd - bStart;\n    if (aLen < bLen) {\n        return -1;\n    }\n    else if (aLen > bLen) {\n        return 1;\n    }\n    return 0;\n}\nexport function compareIgnoreCase(a, b) {\n    return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length);\n}\nexport function compareSubstringIgnoreCase(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n    for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n        let codeA = a.charCodeAt(aStart);\n        let codeB = b.charCodeAt(bStart);\n        if (codeA === codeB) {\n            // equal\n            continue;\n        }\n        if (codeA >= 128 || codeB >= 128) {\n            // not ASCII letters -> fallback to lower-casing strings\n            return compareSubstring(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd);\n        }\n        // mapper lower-case ascii letter onto upper-case varinats\n        // [97-122] (lower ascii) --> [65-90] (upper ascii)\n        if (isLowerAsciiLetter(codeA)) {\n            codeA -= 32;\n        }\n        if (isLowerAsciiLetter(codeB)) {\n            codeB -= 32;\n        }\n        // compare both code points\n        const diff = codeA - codeB;\n        if (diff === 0) {\n            continue;\n        }\n        return diff;\n    }\n    const aLen = aEnd - aStart;\n    const bLen = bEnd - bStart;\n    if (aLen < bLen) {\n        return -1;\n    }\n    else if (aLen > bLen) {\n        return 1;\n    }\n    return 0;\n}\nexport function isLowerAsciiLetter(code) {\n    return code >= 97 /* a */ && code <= 122 /* z */;\n}\nexport function isUpperAsciiLetter(code) {\n    return code >= 65 /* A */ && code <= 90 /* Z */;\n}\nexport function equalsIgnoreCase(a, b) {\n    return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;\n}\nexport function startsWithIgnoreCase(str, candidate) {\n    const candidateLength = candidate.length;\n    if (candidate.length > str.length) {\n        return false;\n    }\n    return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0;\n}\n/**\n * @returns the length of the common prefix of the two strings.\n */\nexport function commonPrefixLength(a, b) {\n    let i, len = Math.min(a.length, b.length);\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(i) !== b.charCodeAt(i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * @returns the length of the common suffix of the two strings.\n */\nexport function commonSuffixLength(a, b) {\n    let i, len = Math.min(a.length, b.length);\n    const aLastIndex = a.length - 1;\n    const bLastIndex = b.length - 1;\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isHighSurrogate(charCode) {\n    return (0xD800 <= charCode && charCode <= 0xDBFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isLowSurrogate(charCode) {\n    return (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function computeCodePoint(highSurrogate, lowSurrogate) {\n    return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;\n}\n/**\n * get the code point that begins at offset `offset`\n */\nexport function getNextCodePoint(str, len, offset) {\n    const charCode = str.charCodeAt(offset);\n    if (isHighSurrogate(charCode) && offset + 1 < len) {\n        const nextCharCode = str.charCodeAt(offset + 1);\n        if (isLowSurrogate(nextCharCode)) {\n            return computeCodePoint(charCode, nextCharCode);\n        }\n    }\n    return charCode;\n}\n/**\n * get the code point that ends right before offset `offset`\n */\nfunction getPrevCodePoint(str, offset) {\n    const charCode = str.charCodeAt(offset - 1);\n    if (isLowSurrogate(charCode) && offset > 1) {\n        const prevCharCode = str.charCodeAt(offset - 2);\n        if (isHighSurrogate(prevCharCode)) {\n            return computeCodePoint(prevCharCode, charCode);\n        }\n    }\n    return charCode;\n}\nexport function nextCharLength(str, offset) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    const initialOffset = offset;\n    const len = str.length;\n    const initialCodePoint = getNextCodePoint(str, len, offset);\n    offset += (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n    let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\n    while (offset < len) {\n        const nextCodePoint = getNextCodePoint(str, len, offset);\n        const nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(nextCodePoint);\n        if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {\n            break;\n        }\n        offset += (nextCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n        graphemeBreakType = nextGraphemeBreakType;\n    }\n    return (offset - initialOffset);\n}\nexport function prevCharLength(str, offset) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    const initialOffset = offset;\n    const initialCodePoint = getPrevCodePoint(str, offset);\n    offset -= (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n    let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\n    while (offset > 0) {\n        const prevCodePoint = getPrevCodePoint(str, offset);\n        const prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(prevCodePoint);\n        if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {\n            break;\n        }\n        offset -= (prevCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n        graphemeBreakType = prevGraphemeBreakType;\n    }\n    return (initialOffset - offset);\n}\n/**\n * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-rtl-test.js\n */\nconst CONTAINS_RTL = /(?:[\\u05BE\\u05C0\\u05C3\\u05C6\\u05D0-\\u05F4\\u0608\\u060B\\u060D\\u061B-\\u064A\\u066D-\\u066F\\u0671-\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1-\\u07EA\\u07F4\\u07F5\\u07FA-\\u0815\\u081A\\u0824\\u0828\\u0830-\\u0858\\u085E-\\u08BD\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFD3D\\uFD50-\\uFDFC\\uFE70-\\uFEFC]|\\uD802[\\uDC00-\\uDD1B\\uDD20-\\uDE00\\uDE10-\\uDE33\\uDE40-\\uDEE4\\uDEEB-\\uDF35\\uDF40-\\uDFFF]|\\uD803[\\uDC00-\\uDCFF]|\\uD83A[\\uDC00-\\uDCCF\\uDD00-\\uDD43\\uDD50-\\uDFFF]|\\uD83B[\\uDC00-\\uDEBB])/;\n/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nexport function containsRTL(str) {\n    return CONTAINS_RTL.test(str);\n}\n/**\n * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-emoji-test.js\n */\nconst 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-\\uDED6])/;\nexport function containsEmoji(str) {\n    return CONTAINS_EMOJI.test(str);\n}\nconst IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\n/**\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\n */\nexport function isBasicASCII(str) {\n    return IS_BASIC_ASCII.test(str);\n}\nexport const UNUSUAL_LINE_TERMINATORS = /[\\u2028\\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)\n/**\n * Returns true if `str` contains unusual line terminators, like LS or PS\n */\nexport function containsUnusualLineTerminators(str) {\n    return UNUSUAL_LINE_TERMINATORS.test(str);\n}\nexport function containsFullWidthCharacter(str) {\n    for (let i = 0, len = str.length; i < len; i++) {\n        if (isFullWidthCharacter(str.charCodeAt(i))) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function isFullWidthCharacter(charCode) {\n    // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n    // http://jrgraphix.net/research/unicode_blocks.php\n    //          2E80 — 2EFF   CJK Radicals Supplement\n    //          2F00 — 2FDF   Kangxi Radicals\n    //          2FF0 — 2FFF   Ideographic Description Characters\n    //          3000 — 303F   CJK Symbols and Punctuation\n    //          3040 — 309F   Hiragana\n    //          30A0 — 30FF   Katakana\n    //          3100 — 312F   Bopomofo\n    //          3130 — 318F   Hangul Compatibility Jamo\n    //          3190 — 319F   Kanbun\n    //          31A0 — 31BF   Bopomofo Extended\n    //          31F0 — 31FF   Katakana Phonetic Extensions\n    //          3200 — 32FF   Enclosed CJK Letters and Months\n    //          3300 — 33FF   CJK Compatibility\n    //          3400 — 4DBF   CJK Unified Ideographs Extension A\n    //          4DC0 — 4DFF   Yijing Hexagram Symbols\n    //          4E00 — 9FFF   CJK Unified Ideographs\n    //          A000 — A48F   Yi Syllables\n    //          A490 — A4CF   Yi Radicals\n    //          AC00 — D7AF   Hangul Syllables\n    // [IGNORE] D800 — DB7F   High Surrogates\n    // [IGNORE] DB80 — DBFF   High Private Use Surrogates\n    // [IGNORE] DC00 — DFFF   Low Surrogates\n    // [IGNORE] E000 — F8FF   Private Use Area\n    //          F900 — FAFF   CJK Compatibility Ideographs\n    // [IGNORE] FB00 — FB4F   Alphabetic Presentation Forms\n    // [IGNORE] FB50 — FDFF   Arabic Presentation Forms-A\n    // [IGNORE] FE00 — FE0F   Variation Selectors\n    // [IGNORE] FE20 — FE2F   Combining Half Marks\n    // [IGNORE] FE30 — FE4F   CJK Compatibility Forms\n    // [IGNORE] FE50 — FE6F   Small Form Variants\n    // [IGNORE] FE70 — FEFF   Arabic Presentation Forms-B\n    //          FF00 — FFEF   Halfwidth and Fullwidth Forms\n    //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n    //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n    // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul\n    // [IGNORE] FFF0 — FFFF   Specials\n    charCode = +charCode; // @perf\n    return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\n        || (charCode >= 0xF900 && charCode <= 0xFAFF)\n        || (charCode >= 0xFF01 && charCode <= 0xFF5E));\n}\n/**\n * A fast function (therefore imprecise) to check if code points are emojis.\n * Generated using https://github.com/alexdima/unicode-utils/blob/master/generate-emoji-test.js\n */\nexport function isEmojiImprecise(x) {\n    return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)\n        || (x === 9203) || (x >= 9728 && x <= 10175) || (x === 11088) || (x === 11093)\n        || (x >= 127744 && x <= 128591) || (x >= 128640 && x <= 128764)\n        || (x >= 128992 && x <= 129003) || (x >= 129280 && x <= 129535)\n        || (x >= 129648 && x <= 129750));\n}\n// -- UTF-8 BOM\nexport const UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);\nexport function startsWithUTF8BOM(str) {\n    return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);\n}\nexport function containsUppercaseCharacter(target, ignoreEscapedChars = false) {\n    if (!target) {\n        return false;\n    }\n    if (ignoreEscapedChars) {\n        target = target.replace(/\\\\./g, '');\n    }\n    return target.toLowerCase() !== target;\n}\n/**\n * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.\n */\nexport function singleLetterHash(n) {\n    const LETTERS_CNT = (90 /* Z */ - 65 /* A */ + 1);\n    n = n % (2 * LETTERS_CNT);\n    if (n < LETTERS_CNT) {\n        return String.fromCharCode(97 /* a */ + n);\n    }\n    return String.fromCharCode(65 /* A */ + n - LETTERS_CNT);\n}\n//#region Unicode Grapheme Break\nexport function getGraphemeBreakType(codePoint) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    return graphemeBreakTree.getGraphemeBreakType(codePoint);\n}\nexport function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {\n    // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules\n    // !!! Let's make the common case a bit faster\n    if (breakTypeA === 0 /* Other */) {\n        // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table\n        return (breakTypeB !== 5 /* Extend */ && breakTypeB !== 7 /* SpacingMark */);\n    }\n    // Do not break between a CR and LF. Otherwise, break before and after controls.\n    // GB3                                        CR × LF\n    // GB4                       (Control | CR | LF) ÷\n    // GB5                                           ÷ (Control | CR | LF)\n    if (breakTypeA === 2 /* CR */) {\n        if (breakTypeB === 3 /* LF */) {\n            return false; // GB3\n        }\n    }\n    if (breakTypeA === 4 /* Control */ || breakTypeA === 2 /* CR */ || breakTypeA === 3 /* LF */) {\n        return true; // GB4\n    }\n    if (breakTypeB === 4 /* Control */ || breakTypeB === 2 /* CR */ || breakTypeB === 3 /* LF */) {\n        return true; // GB5\n    }\n    // Do not break Hangul syllable sequences.\n    // GB6                                         L × (L | V | LV | LVT)\n    // GB7                                  (LV | V) × (V | T)\n    // GB8                                 (LVT | T) × T\n    if (breakTypeA === 8 /* L */) {\n        if (breakTypeB === 8 /* L */ || breakTypeB === 9 /* V */ || breakTypeB === 11 /* LV */ || breakTypeB === 12 /* LVT */) {\n            return false; // GB6\n        }\n    }\n    if (breakTypeA === 11 /* LV */ || breakTypeA === 9 /* V */) {\n        if (breakTypeB === 9 /* V */ || breakTypeB === 10 /* T */) {\n            return false; // GB7\n        }\n    }\n    if (breakTypeA === 12 /* LVT */ || breakTypeA === 10 /* T */) {\n        if (breakTypeB === 10 /* T */) {\n            return false; // GB8\n        }\n    }\n    // Do not break before extending characters or ZWJ.\n    // GB9                                           × (Extend | ZWJ)\n    if (breakTypeB === 5 /* Extend */ || breakTypeB === 13 /* ZWJ */) {\n        return false; // GB9\n    }\n    // The GB9a and GB9b rules only apply to extended grapheme clusters:\n    // Do not break before SpacingMarks, or after Prepend characters.\n    // GB9a                                          × SpacingMark\n    // GB9b                                  Prepend ×\n    if (breakTypeB === 7 /* SpacingMark */) {\n        return false; // GB9a\n    }\n    if (breakTypeA === 1 /* Prepend */) {\n        return false; // GB9b\n    }\n    // Do not break within emoji modifier sequences or emoji zwj sequences.\n    // GB11    \\p{Extended_Pictographic} Extend* ZWJ × \\p{Extended_Pictographic}\n    if (breakTypeA === 13 /* ZWJ */ && breakTypeB === 14 /* Extended_Pictographic */) {\n        // Note: we are not implementing the rule entirely here to avoid introducing states\n        return false; // GB11\n    }\n    // GB12                          sot (RI RI)* RI × RI\n    // GB13                        [^RI] (RI RI)* RI × RI\n    if (breakTypeA === 6 /* Regional_Indicator */ && breakTypeB === 6 /* Regional_Indicator */) {\n        // Note: we are not implementing the rule entirely here to avoid introducing states\n        return false; // GB12 & GB13\n    }\n    // GB999                                     Any ÷ Any\n    return true;\n}\nclass GraphemeBreakTree {\n    constructor() {\n        this._data = getGraphemeBreakRawData();\n    }\n    static getInstance() {\n        if (!GraphemeBreakTree._INSTANCE) {\n            GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();\n        }\n        return GraphemeBreakTree._INSTANCE;\n    }\n    getGraphemeBreakType(codePoint) {\n        // !!! Let's make 7bit ASCII a bit faster: 0..31\n        if (codePoint < 32) {\n            if (codePoint === 10 /* LineFeed */) {\n                return 3 /* LF */;\n            }\n            if (codePoint === 13 /* CarriageReturn */) {\n                return 2 /* CR */;\n            }\n            return 4 /* Control */;\n        }\n        // !!! Let's make 7bit ASCII a bit faster: 32..126\n        if (codePoint < 127) {\n            return 0 /* Other */;\n        }\n        const data = this._data;\n        const nodeCount = data.length / 3;\n        let nodeIndex = 1;\n        while (nodeIndex <= nodeCount) {\n            if (codePoint < data[3 * nodeIndex]) {\n                // go left\n                nodeIndex = 2 * nodeIndex;\n            }\n            else if (codePoint > data[3 * nodeIndex + 1]) {\n                // go right\n                nodeIndex = 2 * nodeIndex + 1;\n            }\n            else {\n                // hit\n                return data[3 * nodeIndex + 2];\n            }\n        }\n        return 0 /* Other */;\n    }\n}\nGraphemeBreakTree._INSTANCE = null;\nfunction getGraphemeBreakRawData() {\n    // generated using https://github.com/alexdima/unicode-utils/blob/master/generate-grapheme-break.js\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]');\n}\n//#endregion\n/**\n * Computes the offset after performing a left delete on the given string,\n * while considering unicode grapheme/emoji rules.\n*/\nexport function getLeftDeleteOffset(offset, str) {\n    if (offset === 0) {\n        return 0;\n    }\n    // Try to delete emoji part.\n    const emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str);\n    if (emojiOffset !== undefined) {\n        return emojiOffset;\n    }\n    // Otherwise, just skip a single code point.\n    const codePoint = getPrevCodePoint(str, offset);\n    offset -= getUTF16Length(codePoint);\n    return offset;\n}\nfunction getOffsetBeforeLastEmojiComponent(offset, str) {\n    // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the\n    // structure of emojis.\n    let codePoint = getPrevCodePoint(str, offset);\n    offset -= getUTF16Length(codePoint);\n    // Skip modifiers\n    while ((isEmojiModifier(codePoint) || codePoint === 65039 /* emojiVariantSelector */ || codePoint === 8419 /* enclosingKeyCap */)) {\n        if (offset === 0) {\n            // Cannot skip modifier, no preceding emoji base.\n            return undefined;\n        }\n        codePoint = getPrevCodePoint(str, offset);\n        offset -= getUTF16Length(codePoint);\n    }\n    // Expect base emoji\n    if (!isEmojiImprecise(codePoint)) {\n        // Unexpected code point, not a valid emoji.\n        return undefined;\n    }\n    if (offset >= 0) {\n        // Skip optional ZWJ code points that combine multiple emojis.\n        // In theory, we should check if that ZWJ actually combines multiple emojis\n        // to prevent deleting ZWJs in situations we didn't account for.\n        const optionalZwjCodePoint = getPrevCodePoint(str, offset);\n        if (optionalZwjCodePoint === 8205 /* zwj */) {\n            offset -= getUTF16Length(optionalZwjCodePoint);\n        }\n    }\n    return offset;\n}\nfunction getUTF16Length(codePoint) {\n    return codePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;\n}\nfunction isEmojiModifier(codePoint) {\n    return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { transformErrorForSerialization } from '../errors.js';\nimport { Emitter } from '../event.js';\nimport { Disposable } from '../lifecycle.js';\nimport { globals, isWeb } from '../platform.js';\nimport * as types from '../types.js';\nimport * as strings from '../strings.js';\nconst INITIALIZE = '$initialize';\nlet webWorkerWarningLogged = false;\nexport function logOnceWebWorkerWarning(err) {\n    if (!isWeb) {\n        // running tests\n        return;\n    }\n    if (!webWorkerWarningLogged) {\n        webWorkerWarningLogged = true;\n        console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq');\n    }\n    console.warn(err.message);\n}\nclass RequestMessage {\n    constructor(vsWorker, req, method, args) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.method = method;\n        this.args = args;\n        this.type = 0 /* Request */;\n    }\n}\nclass ReplyMessage {\n    constructor(vsWorker, seq, res, err) {\n        this.vsWorker = vsWorker;\n        this.seq = seq;\n        this.res = res;\n        this.err = err;\n        this.type = 1 /* Reply */;\n    }\n}\nclass SubscribeEventMessage {\n    constructor(vsWorker, req, eventName, arg) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.eventName = eventName;\n        this.arg = arg;\n        this.type = 2 /* SubscribeEvent */;\n    }\n}\nclass EventMessage {\n    constructor(vsWorker, req, event) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.event = event;\n        this.type = 3 /* Event */;\n    }\n}\nclass UnsubscribeEventMessage {\n    constructor(vsWorker, req) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.type = 4 /* UnsubscribeEvent */;\n    }\n}\nclass SimpleWorkerProtocol {\n    constructor(handler) {\n        this._workerId = -1;\n        this._handler = handler;\n        this._lastSentReq = 0;\n        this._pendingReplies = Object.create(null);\n        this._pendingEmitters = new Map();\n        this._pendingEvents = new Map();\n    }\n    setWorkerId(workerId) {\n        this._workerId = workerId;\n    }\n    sendMessage(method, args) {\n        const req = String(++this._lastSentReq);\n        return new Promise((resolve, reject) => {\n            this._pendingReplies[req] = {\n                resolve: resolve,\n                reject: reject\n            };\n            this._send(new RequestMessage(this._workerId, req, method, args));\n        });\n    }\n    listen(eventName, arg) {\n        let req = null;\n        const emitter = new Emitter({\n            onFirstListenerAdd: () => {\n                req = String(++this._lastSentReq);\n                this._pendingEmitters.set(req, emitter);\n                this._send(new SubscribeEventMessage(this._workerId, req, eventName, arg));\n            },\n            onLastListenerRemove: () => {\n                this._pendingEmitters.delete(req);\n                this._send(new UnsubscribeEventMessage(this._workerId, req));\n                req = null;\n            }\n        });\n        return emitter.event;\n    }\n    handleMessage(message) {\n        if (!message || !message.vsWorker) {\n            return;\n        }\n        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n            return;\n        }\n        this._handleMessage(message);\n    }\n    _handleMessage(msg) {\n        switch (msg.type) {\n            case 1 /* Reply */:\n                return this._handleReplyMessage(msg);\n            case 0 /* Request */:\n                return this._handleRequestMessage(msg);\n            case 2 /* SubscribeEvent */:\n                return this._handleSubscribeEventMessage(msg);\n            case 3 /* Event */:\n                return this._handleEventMessage(msg);\n            case 4 /* UnsubscribeEvent */:\n                return this._handleUnsubscribeEventMessage(msg);\n        }\n    }\n    _handleReplyMessage(replyMessage) {\n        if (!this._pendingReplies[replyMessage.seq]) {\n            console.warn('Got reply to unknown seq');\n            return;\n        }\n        let reply = this._pendingReplies[replyMessage.seq];\n        delete this._pendingReplies[replyMessage.seq];\n        if (replyMessage.err) {\n            let err = replyMessage.err;\n            if (replyMessage.err.$isError) {\n                err = new Error();\n                err.name = replyMessage.err.name;\n                err.message = replyMessage.err.message;\n                err.stack = replyMessage.err.stack;\n            }\n            reply.reject(err);\n            return;\n        }\n        reply.resolve(replyMessage.res);\n    }\n    _handleRequestMessage(requestMessage) {\n        let req = requestMessage.req;\n        let result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n        result.then((r) => {\n            this._send(new ReplyMessage(this._workerId, req, r, undefined));\n        }, (e) => {\n            if (e.detail instanceof Error) {\n                // Loading errors have a detail property that points to the actual error\n                e.detail = transformErrorForSerialization(e.detail);\n            }\n            this._send(new ReplyMessage(this._workerId, req, undefined, transformErrorForSerialization(e)));\n        });\n    }\n    _handleSubscribeEventMessage(msg) {\n        const req = msg.req;\n        const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => {\n            this._send(new EventMessage(this._workerId, req, event));\n        });\n        this._pendingEvents.set(req, disposable);\n    }\n    _handleEventMessage(msg) {\n        if (!this._pendingEmitters.has(msg.req)) {\n            console.warn('Got event for unknown req');\n            return;\n        }\n        this._pendingEmitters.get(msg.req).fire(msg.event);\n    }\n    _handleUnsubscribeEventMessage(msg) {\n        if (!this._pendingEvents.has(msg.req)) {\n            console.warn('Got unsubscribe for unknown req');\n            return;\n        }\n        this._pendingEvents.get(msg.req).dispose();\n        this._pendingEvents.delete(msg.req);\n    }\n    _send(msg) {\n        let transfer = [];\n        if (msg.type === 0 /* Request */) {\n            for (let i = 0; i < msg.args.length; i++) {\n                if (msg.args[i] instanceof ArrayBuffer) {\n                    transfer.push(msg.args[i]);\n                }\n            }\n        }\n        else if (msg.type === 1 /* Reply */) {\n            if (msg.res instanceof ArrayBuffer) {\n                transfer.push(msg.res);\n            }\n        }\n        this._handler.sendMessage(msg, transfer);\n    }\n}\n/**\n * Main thread side\n */\nexport class SimpleWorkerClient extends Disposable {\n    constructor(workerFactory, moduleId, host) {\n        super();\n        let lazyProxyReject = null;\n        this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => {\n            this._protocol.handleMessage(msg);\n        }, (err) => {\n            // in Firefox, web workers fail lazily :(\n            // we will reject the proxy\n            if (lazyProxyReject) {\n                lazyProxyReject(err);\n            }\n        }));\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: (msg, transfer) => {\n                this._worker.postMessage(msg, transfer);\n            },\n            handleMessage: (method, args) => {\n                if (typeof host[method] !== 'function') {\n                    return Promise.reject(new Error('Missing method ' + method + ' on main thread host.'));\n                }\n                try {\n                    return Promise.resolve(host[method].apply(host, args));\n                }\n                catch (e) {\n                    return Promise.reject(e);\n                }\n            },\n            handleEvent: (eventName, arg) => {\n                if (propertyIsDynamicEvent(eventName)) {\n                    const event = host[eventName].call(host, arg);\n                    if (typeof event !== 'function') {\n                        throw new Error(`Missing dynamic event ${eventName} on main thread host.`);\n                    }\n                    return event;\n                }\n                if (propertyIsEvent(eventName)) {\n                    const event = host[eventName];\n                    if (typeof event !== 'function') {\n                        throw new Error(`Missing event ${eventName} on main thread host.`);\n                    }\n                    return event;\n                }\n                throw new Error(`Malformed event name ${eventName}`);\n            }\n        });\n        this._protocol.setWorkerId(this._worker.getId());\n        // Gather loader configuration\n        let loaderConfiguration = null;\n        if (typeof globals.require !== 'undefined' && typeof globals.require.getConfig === 'function') {\n            // Get the configuration from the Monaco AMD Loader\n            loaderConfiguration = globals.require.getConfig();\n        }\n        else if (typeof globals.requirejs !== 'undefined') {\n            // Get the configuration from requirejs\n            loaderConfiguration = globals.requirejs.s.contexts._.config;\n        }\n        const hostMethods = types.getAllMethodNames(host);\n        // Send initialize message\n        this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [\n            this._worker.getId(),\n            JSON.parse(JSON.stringify(loaderConfiguration)),\n            moduleId,\n            hostMethods,\n        ]);\n        // Create proxy to loaded code\n        const proxyMethodRequest = (method, args) => {\n            return this._request(method, args);\n        };\n        const proxyListen = (eventName, arg) => {\n            return this._protocol.listen(eventName, arg);\n        };\n        this._lazyProxy = new Promise((resolve, reject) => {\n            lazyProxyReject = reject;\n            this._onModuleLoaded.then((availableMethods) => {\n                resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen));\n            }, (e) => {\n                reject(e);\n                this._onError('Worker failed to load ' + moduleId, e);\n            });\n        });\n    }\n    getProxyObject() {\n        return this._lazyProxy;\n    }\n    _request(method, args) {\n        return new Promise((resolve, reject) => {\n            this._onModuleLoaded.then(() => {\n                this._protocol.sendMessage(method, args).then(resolve, reject);\n            }, reject);\n        });\n    }\n    _onError(message, error) {\n        console.error(message);\n        console.info(error);\n    }\n}\nfunction propertyIsEvent(name) {\n    // Assume a property is an event if it has a form of \"onSomething\"\n    return name[0] === 'o' && name[1] === 'n' && strings.isUpperAsciiLetter(name.charCodeAt(2));\n}\nfunction propertyIsDynamicEvent(name) {\n    // Assume a property is a dynamic event (a method that returns an event) if it has a form of \"onDynamicSomething\"\n    return /^onDynamic/.test(name) && strings.isUpperAsciiLetter(name.charCodeAt(9));\n}\nfunction createProxyObject(methodNames, invoke, proxyListen) {\n    const createProxyMethod = (method) => {\n        return function () {\n            const args = Array.prototype.slice.call(arguments, 0);\n            return invoke(method, args);\n        };\n    };\n    const createProxyDynamicEvent = (eventName) => {\n        return function (arg) {\n            return proxyListen(eventName, arg);\n        };\n    };\n    let result = {};\n    for (const methodName of methodNames) {\n        if (propertyIsDynamicEvent(methodName)) {\n            result[methodName] = createProxyDynamicEvent(methodName);\n            continue;\n        }\n        if (propertyIsEvent(methodName)) {\n            result[methodName] = proxyListen(methodName, undefined);\n            continue;\n        }\n        result[methodName] = createProxyMethod(methodName);\n    }\n    return result;\n}\n/**\n * Worker side\n */\nexport class SimpleWorkerServer {\n    constructor(postMessage, requestHandlerFactory) {\n        this._requestHandlerFactory = requestHandlerFactory;\n        this._requestHandler = null;\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: (msg, transfer) => {\n                postMessage(msg, transfer);\n            },\n            handleMessage: (method, args) => this._handleMessage(method, args),\n            handleEvent: (eventName, arg) => this._handleEvent(eventName, arg)\n        });\n    }\n    onmessage(msg) {\n        this._protocol.handleMessage(msg);\n    }\n    _handleMessage(method, args) {\n        if (method === INITIALIZE) {\n            return this.initialize(args[0], args[1], args[2], args[3]);\n        }\n        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    }\n    _handleEvent(eventName, arg) {\n        if (!this._requestHandler) {\n            throw new Error(`Missing requestHandler`);\n        }\n        if (propertyIsDynamicEvent(eventName)) {\n            const event = this._requestHandler[eventName].call(this._requestHandler, arg);\n            if (typeof event !== 'function') {\n                throw new Error(`Missing dynamic event ${eventName} on request handler.`);\n            }\n            return event;\n        }\n        if (propertyIsEvent(eventName)) {\n            const event = this._requestHandler[eventName];\n            if (typeof event !== 'function') {\n                throw new Error(`Missing event ${eventName} on request handler.`);\n            }\n            return event;\n        }\n        throw new Error(`Malformed event name ${eventName}`);\n    }\n    initialize(workerId, loaderConfig, moduleId, hostMethods) {\n        this._protocol.setWorkerId(workerId);\n        const proxyMethodRequest = (method, args) => {\n            return this._protocol.sendMessage(method, args);\n        };\n        const proxyListen = (eventName, arg) => {\n            return this._protocol.listen(eventName, arg);\n        };\n        const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen);\n        if (this._requestHandlerFactory) {\n            // static request handler\n            this._requestHandler = this._requestHandlerFactory(hostProxy);\n            return Promise.resolve(types.getAllMethodNames(this._requestHandler));\n        }\n        if (loaderConfig) {\n            // Remove 'baseUrl', handling it is beyond scope for now\n            if (typeof loaderConfig.baseUrl !== 'undefined') {\n                delete loaderConfig['baseUrl'];\n            }\n            if (typeof loaderConfig.paths !== 'undefined') {\n                if (typeof loaderConfig.paths.vs !== 'undefined') {\n                    delete loaderConfig.paths['vs'];\n                }\n            }\n            if (typeof loaderConfig.trustedTypesPolicy !== undefined) {\n                // don't use, it has been destroyed during serialize\n                delete loaderConfig['trustedTypesPolicy'];\n            }\n            // Since this is in a web worker, enable catching errors\n            loaderConfig.catchError = true;\n            globals.require.config(loaderConfig);\n        }\n        return new Promise((resolve, reject) => {\n            // Use the global require to be sure to get the global config\n            // ESM-comment-begin\n            // \t\t\tconst req = (globals.require || require);\n            // ESM-comment-end\n            // ESM-uncomment-begin\n            const req = globals.require;\n            // ESM-uncomment-end\n            req([moduleId], (module) => {\n                this._requestHandler = module.create(hostProxy);\n                if (!this._requestHandler) {\n                    reject(new Error(`No RequestHandler!`));\n                    return;\n                }\n                resolve(types.getAllMethodNames(this._requestHandler));\n            }, reject);\n        });\n    }\n}\n/**\n * Called on the worker side\n */\nexport function create(postMessage) {\n    return new SimpleWorkerServer(postMessage, null);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nexport class DiffChange {\n    /**\n     * Constructs a new DiffChange with the given sequence information\n     * and content.\n     */\n    constructor(originalStart, originalLength, modifiedStart, modifiedLength) {\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n        this.originalStart = originalStart;\n        this.originalLength = originalLength;\n        this.modifiedStart = modifiedStart;\n        this.modifiedLength = modifiedLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the original sequence.\n     */\n    getOriginalEnd() {\n        return this.originalStart + this.originalLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the modified sequence.\n     */\n    getModifiedEnd() {\n        return this.modifiedStart + this.modifiedLength;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from './strings.js';\n/**\n * Return a hash value for an object.\n */\nexport function hash(obj) {\n    return doHash(obj, 0);\n}\nexport function doHash(obj, hashVal) {\n    switch (typeof obj) {\n        case 'object':\n            if (obj === null) {\n                return numberHash(349, hashVal);\n            }\n            else if (Array.isArray(obj)) {\n                return arrayHash(obj, hashVal);\n            }\n            return objectHash(obj, hashVal);\n        case 'string':\n            return stringHash(obj, hashVal);\n        case 'boolean':\n            return booleanHash(obj, hashVal);\n        case 'number':\n            return numberHash(obj, hashVal);\n        case 'undefined':\n            return numberHash(937, hashVal);\n        default:\n            return numberHash(617, hashVal);\n    }\n}\nexport function numberHash(val, initialHashVal) {\n    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32\n}\nfunction booleanHash(b, initialHashVal) {\n    return numberHash(b ? 433 : 863, initialHashVal);\n}\nexport function stringHash(s, hashVal) {\n    hashVal = numberHash(149417, hashVal);\n    for (let i = 0, length = s.length; i < length; i++) {\n        hashVal = numberHash(s.charCodeAt(i), hashVal);\n    }\n    return hashVal;\n}\nfunction arrayHash(arr, initialHashVal) {\n    initialHashVal = numberHash(104579, initialHashVal);\n    return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);\n}\nfunction objectHash(obj, initialHashVal) {\n    initialHashVal = numberHash(181387, initialHashVal);\n    return Object.keys(obj).sort().reduce((hashVal, key) => {\n        hashVal = stringHash(key, hashVal);\n        return doHash(obj[key], hashVal);\n    }, initialHashVal);\n}\nfunction leftRotate(value, bits, totalBits = 32) {\n    // delta + bits = totalBits\n    const delta = totalBits - bits;\n    // All ones, expect `delta` zeros aligned to the right\n    const mask = ~((1 << delta) - 1);\n    // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)\n    return ((value << bits) | ((mask & value) >>> delta)) >>> 0;\n}\nfunction fill(dest, index = 0, count = dest.byteLength, value = 0) {\n    for (let i = 0; i < count; i++) {\n        dest[index + i] = value;\n    }\n}\nfunction leftPad(value, length, char = '0') {\n    while (value.length < length) {\n        value = char + value;\n    }\n    return value;\n}\nexport function toHexString(bufferOrValue, bitsize = 32) {\n    if (bufferOrValue instanceof ArrayBuffer) {\n        return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');\n    }\n    return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);\n}\n/**\n * A SHA1 implementation that works with strings and does not allocate.\n */\nexport class StringSHA1 {\n    constructor() {\n        this._h0 = 0x67452301;\n        this._h1 = 0xEFCDAB89;\n        this._h2 = 0x98BADCFE;\n        this._h3 = 0x10325476;\n        this._h4 = 0xC3D2E1F0;\n        this._buff = new Uint8Array(64 /* BLOCK_SIZE */ + 3 /* to fit any utf-8 */);\n        this._buffDV = new DataView(this._buff.buffer);\n        this._buffLen = 0;\n        this._totalLen = 0;\n        this._leftoverHighSurrogate = 0;\n        this._finished = false;\n    }\n    update(str) {\n        const strLen = str.length;\n        if (strLen === 0) {\n            return;\n        }\n        const buff = this._buff;\n        let buffLen = this._buffLen;\n        let leftoverHighSurrogate = this._leftoverHighSurrogate;\n        let charCode;\n        let offset;\n        if (leftoverHighSurrogate !== 0) {\n            charCode = leftoverHighSurrogate;\n            offset = -1;\n            leftoverHighSurrogate = 0;\n        }\n        else {\n            charCode = str.charCodeAt(0);\n            offset = 0;\n        }\n        while (true) {\n            let codePoint = charCode;\n            if (strings.isHighSurrogate(charCode)) {\n                if (offset + 1 < strLen) {\n                    const nextCharCode = str.charCodeAt(offset + 1);\n                    if (strings.isLowSurrogate(nextCharCode)) {\n                        offset++;\n                        codePoint = strings.computeCodePoint(charCode, nextCharCode);\n                    }\n                    else {\n                        // illegal => unicode replacement character\n                        codePoint = 65533 /* UNICODE_REPLACEMENT */;\n                    }\n                }\n                else {\n                    // last character is a surrogate pair\n                    leftoverHighSurrogate = charCode;\n                    break;\n                }\n            }\n            else if (strings.isLowSurrogate(charCode)) {\n                // illegal => unicode replacement character\n                codePoint = 65533 /* UNICODE_REPLACEMENT */;\n            }\n            buffLen = this._push(buff, buffLen, codePoint);\n            offset++;\n            if (offset < strLen) {\n                charCode = str.charCodeAt(offset);\n            }\n            else {\n                break;\n            }\n        }\n        this._buffLen = buffLen;\n        this._leftoverHighSurrogate = leftoverHighSurrogate;\n    }\n    _push(buff, buffLen, codePoint) {\n        if (codePoint < 0x0080) {\n            buff[buffLen++] = codePoint;\n        }\n        else if (codePoint < 0x0800) {\n            buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else if (codePoint < 0x10000) {\n            buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else {\n            buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        if (buffLen >= 64 /* BLOCK_SIZE */) {\n            this._step();\n            buffLen -= 64 /* BLOCK_SIZE */;\n            this._totalLen += 64 /* BLOCK_SIZE */;\n            // take last 3 in case of UTF8 overflow\n            buff[0] = buff[64 /* BLOCK_SIZE */ + 0];\n            buff[1] = buff[64 /* BLOCK_SIZE */ + 1];\n            buff[2] = buff[64 /* BLOCK_SIZE */ + 2];\n        }\n        return buffLen;\n    }\n    digest() {\n        if (!this._finished) {\n            this._finished = true;\n            if (this._leftoverHighSurrogate) {\n                // illegal => unicode replacement character\n                this._leftoverHighSurrogate = 0;\n                this._buffLen = this._push(this._buff, this._buffLen, 65533 /* UNICODE_REPLACEMENT */);\n            }\n            this._totalLen += this._buffLen;\n            this._wrapUp();\n        }\n        return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);\n    }\n    _wrapUp() {\n        this._buff[this._buffLen++] = 0x80;\n        fill(this._buff, this._buffLen);\n        if (this._buffLen > 56) {\n            this._step();\n            fill(this._buff);\n        }\n        // this will fit because the mantissa can cover up to 52 bits\n        const ml = 8 * this._totalLen;\n        this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);\n        this._buffDV.setUint32(60, ml % 4294967296, false);\n        this._step();\n    }\n    _step() {\n        const bigBlock32 = StringSHA1._bigBlock32;\n        const data = this._buffDV;\n        for (let j = 0; j < 64 /* 16*4 */; j += 4) {\n            bigBlock32.setUint32(j, data.getUint32(j, false), false);\n        }\n        for (let j = 64; j < 320 /* 80*4 */; j += 4) {\n            bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);\n        }\n        let a = this._h0;\n        let b = this._h1;\n        let c = this._h2;\n        let d = this._h3;\n        let e = this._h4;\n        let f, k;\n        let temp;\n        for (let j = 0; j < 80; j++) {\n            if (j < 20) {\n                f = (b & c) | ((~b) & d);\n                k = 0x5A827999;\n            }\n            else if (j < 40) {\n                f = b ^ c ^ d;\n                k = 0x6ED9EBA1;\n            }\n            else if (j < 60) {\n                f = (b & c) | (b & d) | (c & d);\n                k = 0x8F1BBCDC;\n            }\n            else {\n                f = b ^ c ^ d;\n                k = 0xCA62C1D6;\n            }\n            temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;\n            e = d;\n            d = c;\n            c = leftRotate(b, 30);\n            b = a;\n            a = temp;\n        }\n        this._h0 = (this._h0 + a) & 0xffffffff;\n        this._h1 = (this._h1 + b) & 0xffffffff;\n        this._h2 = (this._h2 + c) & 0xffffffff;\n        this._h3 = (this._h3 + d) & 0xffffffff;\n        this._h4 = (this._h4 + e) & 0xffffffff;\n    }\n}\nStringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { DiffChange } from './diffChange.js';\nimport { stringHash } from '../hash.js';\nexport class StringDiffSequence {\n    constructor(source) {\n        this.source = source;\n    }\n    getElements() {\n        const source = this.source;\n        const characters = new Int32Array(source.length);\n        for (let i = 0, len = source.length; i < len; i++) {\n            characters[i] = source.charCodeAt(i);\n        }\n        return characters;\n    }\n}\nexport function stringDiff(original, modified, pretty) {\n    return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nexport class Debug {\n    static Assert(condition, message) {\n        if (!condition) {\n            throw new Error(message);\n        }\n    }\n}\nexport class MyArray {\n    /**\n     * Copies a range of elements from an Array starting at the specified source index and pastes\n     * them to another Array starting at the specified destination index. The length and the indexes\n     * are specified as 64-bit integers.\n     * sourceArray:\n     *\t\tThe Array that contains the data to copy.\n     * sourceIndex:\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n     * destinationArray:\n     *\t\tThe Array that receives the data.\n     * destinationIndex:\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n     * length:\n     *\t\tA 64-bit integer that represents the number of elements to copy.\n     */\n    static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n    static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n}\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarkNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nclass DiffChangeHelper {\n    /**\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\n     */\n    constructor() {\n        this.m_changes = [];\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n    }\n    /**\n     * Marks the beginning of the next change in the set of differences.\n     */\n    MarkNextChange() {\n        // Only add to the list if there is something to add\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Add the new change to our list\n            this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n        }\n        // Reset for the next change\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n    }\n    /**\n     * Adds the original element at the given position to the elements\n     * affected by the current change. The modified index gives context\n     * to the change position with respect to the original sequence.\n     * @param originalIndex The index of the original element to add.\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n     */\n    AddOriginalElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_originalCount++;\n    }\n    /**\n     * Adds the modified element at the given position to the elements\n     * affected by the current change. The original index gives context\n     * to the change position with respect to the modified sequence.\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n     * @param modifiedIndex The index of the modified element to add.\n     */\n    AddModifiedElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_modifiedCount++;\n    }\n    /**\n     * Retrieves all of the changes marked by the class.\n     */\n    getChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        return this.m_changes;\n    }\n    /**\n     * Retrieves all of the changes marked by the class in the reverse order\n     */\n    getReverseChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        this.m_changes.reverse();\n        return this.m_changes;\n    }\n}\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nexport class LcsDiff {\n    /**\n     * Constructs the DiffFinder\n     */\n    constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) {\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\n        this._originalSequence = originalSequence;\n        this._modifiedSequence = modifiedSequence;\n        const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence);\n        const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence);\n        this._hasStrings = (originalHasStrings && modifiedHasStrings);\n        this._originalStringElements = originalStringElements;\n        this._originalElementsOrHash = originalElementsOrHash;\n        this._modifiedStringElements = modifiedStringElements;\n        this._modifiedElementsOrHash = modifiedElementsOrHash;\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n    }\n    static _isStringArray(arr) {\n        return (arr.length > 0 && typeof arr[0] === 'string');\n    }\n    static _getElements(sequence) {\n        const elements = sequence.getElements();\n        if (LcsDiff._isStringArray(elements)) {\n            const hashes = new Int32Array(elements.length);\n            for (let i = 0, len = elements.length; i < len; i++) {\n                hashes[i] = stringHash(elements[i], 0);\n            }\n            return [elements, hashes, true];\n        }\n        if (elements instanceof Int32Array) {\n            return [[], elements, false];\n        }\n        return [[], new Int32Array(elements), false];\n    }\n    ElementsAreEqual(originalIndex, newIndex) {\n        if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);\n    }\n    ElementsAreStrictEqual(originalIndex, newIndex) {\n        if (!this.ElementsAreEqual(originalIndex, newIndex)) {\n            return false;\n        }\n        const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);\n        const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);\n        return (originalElement === modifiedElement);\n    }\n    static _getStrictElement(sequence, index) {\n        if (typeof sequence.getStrictElement === 'function') {\n            return sequence.getStrictElement(index);\n        }\n        return null;\n    }\n    OriginalElementsAreEqual(index1, index2) {\n        if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);\n    }\n    ModifiedElementsAreEqual(index1, index2) {\n        if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);\n    }\n    ComputeDiff(pretty) {\n        return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);\n    }\n    /**\n     * Computes the differences between the original and modified input\n     * sequences on the bounded range.\n     * @returns An array of the differences between the two input sequences.\n     */\n    _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n        const quitEarlyArr = [false];\n        let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n        if (pretty) {\n            // We have to clean up the computed diff to be more intuitive\n            // but it turns out this cannot be done correctly until the entire set\n            // of diffs have been computed\n            changes = this.PrettifyChanges(changes);\n        }\n        return {\n            quitEarly: quitEarlyArr[0],\n            changes: changes\n        };\n    }\n    /**\n     * Private helper method which computes the differences on the bounded range\n     * recursively.\n     * @returns An array of the differences between the two input sequences.\n     */\n    ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n        quitEarlyArr[0] = false;\n        // Find the start of the differences\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n            originalStart++;\n            modifiedStart++;\n        }\n        // Find the end of the differences\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n            originalEnd--;\n            modifiedEnd--;\n        }\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n            let changes;\n            if (modifiedStart <= modifiedEnd) {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                // All insertions\n                changes = [\n                    new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n                ];\n            }\n            else if (originalStart <= originalEnd) {\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // All deletions\n                changes = [\n                    new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n                ];\n            }\n            else {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // Identical sequences - No differences\n                changes = [];\n            }\n            return changes;\n        }\n        // This problem can be solved using the Divide-And-Conquer technique.\n        const midOriginalArr = [0];\n        const midModifiedArr = [0];\n        const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n        const midOriginal = midOriginalArr[0];\n        const midModified = midModifiedArr[0];\n        if (result !== null) {\n            // Result is not-null when there was enough memory to compute the changes while\n            // searching for the recursion point\n            return result;\n        }\n        else if (!quitEarlyArr[0]) {\n            // We can break the problem down recursively by finding the changes in the\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n            const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n            let rightChanges = [];\n            if (!quitEarlyArr[0]) {\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n            }\n            else {\n                // We didn't have time to finish the first half, so we don't have time to compute this half.\n                // Consider the entire rest of the sequence different.\n                rightChanges = [\n                    new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n                ];\n            }\n            return this.ConcatenateChanges(leftChanges, rightChanges);\n        }\n        // If we hit here, we quit early, and so can't return anything meaningful\n        return [\n            new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n        ];\n    }\n    WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n        let forwardChanges = null;\n        let reverseChanges = null;\n        // First, walk backward through the forward diagonals history\n        let changeHelper = new DiffChangeHelper();\n        let diagonalMin = diagonalForwardStart;\n        let diagonalMax = diagonalForwardEnd;\n        let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n        let lastOriginalIndex = -1073741824 /* MIN_SAFE_SMALL_INTEGER */;\n        let historyIndex = this.m_forwardHistory.length - 1;\n        do {\n            // Get the diagonal index from the relative diagonal number\n            const diagonal = diagonalRelative + diagonalForwardBase;\n            // Figure out where we came from\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                // Vertical line (the element is an insert)\n                originalIndex = forwardPoints[diagonal + 1];\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex;\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            else {\n                // Horizontal line (the element is a deletion)\n                originalIndex = forwardPoints[diagonal - 1] + 1;\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex - 1;\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            if (historyIndex >= 0) {\n                forwardPoints = this.m_forwardHistory[historyIndex];\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n                diagonalMin = 1;\n                diagonalMax = forwardPoints.length - 1;\n            }\n        } while (--historyIndex >= -1);\n        // Ironically, we get the forward changes as the reverse of the\n        // order we added them since we technically added them backwards\n        forwardChanges = changeHelper.getReverseChanges();\n        if (quitEarlyArr[0]) {\n            // TODO: Calculate a partial from the reverse diagonals.\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\n            let originalStartPoint = midOriginalArr[0] + 1;\n            let modifiedStartPoint = midModifiedArr[0] + 1;\n            if (forwardChanges !== null && forwardChanges.length > 0) {\n                const lastForwardChange = forwardChanges[forwardChanges.length - 1];\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n            }\n            reverseChanges = [\n                new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n            ];\n        }\n        else {\n            // Now walk backward through the reverse diagonals history\n            changeHelper = new DiffChangeHelper();\n            diagonalMin = diagonalReverseStart;\n            diagonalMax = diagonalReverseEnd;\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n            lastOriginalIndex = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n            do {\n                // Get the diagonal index from the relative diagonal number\n                const diagonal = diagonalRelative + diagonalReverseBase;\n                // Figure out where we came from\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    // Horizontal line (the element is a deletion))\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex + 1;\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                else {\n                    // Vertical line (the element is an insertion)\n                    originalIndex = reversePoints[diagonal - 1];\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex;\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                if (historyIndex >= 0) {\n                    reversePoints = this.m_reverseHistory[historyIndex];\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n                    diagonalMin = 1;\n                    diagonalMax = reversePoints.length - 1;\n                }\n            } while (--historyIndex >= -1);\n            // There are cases where the reverse history will find diffs that\n            // are correct, but not intuitive, so we need shift them.\n            reverseChanges = changeHelper.getChanges();\n        }\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\n    }\n    /**\n     * Given the range to compute the diff on, this method finds the point:\n     * (midOriginal, midModified)\n     * that exists in the middle of the LCS of the two sequences and\n     * is the point at which the LCS problem may be broken down recursively.\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\n     * point is calculated and the full trace is available in memory, then this method\n     * will return the change list.\n     * @param originalStart The start bound of the original sequence range\n     * @param originalEnd The end bound of the original sequence range\n     * @param modifiedStart The start bound of the modified sequence range\n     * @param modifiedEnd The end bound of the modified sequence range\n     * @param midOriginal The middle point of the original sequence range\n     * @param midModified The middle point of the modified sequence range\n     * @returns The diff changes, if available, otherwise null\n     */\n    ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n        let originalIndex = 0, modifiedIndex = 0;\n        let diagonalForwardStart = 0, diagonalForwardEnd = 0;\n        let diagonalReverseStart = 0, diagonalReverseEnd = 0;\n        // To traverse the edit graph and produce the proper LCS, our actual\n        // start position is just outside the given boundary\n        originalStart--;\n        modifiedStart--;\n        // We set these up to make the compiler happy, but they will\n        // be replaced before we return with the actual recursion point\n        midOriginalArr[0] = 0;\n        midModifiedArr[0] = 0;\n        // Clear out the history\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n        // The integer value in the cell represents the originalIndex of the furthest\n        // reaching point found so far that ends in that diagonal.\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n        const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n        const numDiagonals = maxDifferences + 1;\n        const forwardPoints = new Int32Array(numDiagonals);\n        const reversePoints = new Int32Array(numDiagonals);\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n        const diagonalForwardBase = (modifiedEnd - modifiedStart);\n        const diagonalReverseBase = (originalEnd - originalStart);\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalForwardBase)\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalReverseBase)\n        const diagonalForwardOffset = (originalStart - modifiedStart);\n        const diagonalReverseOffset = (originalEnd - modifiedEnd);\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n        const delta = diagonalReverseBase - diagonalForwardBase;\n        const deltaIsEven = (delta % 2 === 0);\n        // Here we set up the start and end points as the furthest points found so far\n        // in both the forward and reverse directions, respectively\n        forwardPoints[diagonalForwardBase] = originalStart;\n        reversePoints[diagonalReverseBase] = originalEnd;\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n        quitEarlyArr[0] = false;\n        // A couple of points:\n        // --With this method, we iterate on the number of differences between the two sequences.\n        //   The more differences there actually are, the longer this will take.\n        // --Also, as the number of differences increases, we have to search on diagonals further\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n        //   is even and odd diagonals only when numDifferences is odd.\n        for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n            let furthestOriginalIndex = 0;\n            let furthestModifiedIndex = 0;\n            // Run the algorithm in the forward direction\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalStart, modifiedStart)\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                    originalIndex = forwardPoints[diagonal + 1];\n                }\n                else {\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n                // Save the current originalIndex so we can test for false overlap in step 3\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // so long as the elements are equal.\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n                    originalIndex++;\n                    modifiedIndex++;\n                }\n                forwardPoints[diagonal] = originalIndex;\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n                    furthestOriginalIndex = originalIndex;\n                    furthestModifiedIndex = modifiedIndex;\n                }\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n                // then check for overlap.\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n                    if (originalIndex >= reversePoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Check to see if we should be quitting early, before moving on to the next iteration.\n            const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {\n                // We can't finish, so skip ahead to generating a result from what we have.\n                quitEarlyArr[0] = true;\n                // Use the furthest distance we got in the forward direction.\n                midOriginalArr[0] = furthestOriginalIndex;\n                midModifiedArr[0] = furthestModifiedIndex;\n                if (matchLengthOfLongest > 0 && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                    // Enough of the history is in memory to walk it backwards\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                }\n                else {\n                    // We didn't actually remember enough of the history.\n                    //Since we are quitting the diff early, we need to shift back the originalStart and modified start\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\n                    originalStart++;\n                    modifiedStart++;\n                    return [\n                        new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n                    ];\n                }\n            }\n            // Run the algorithm in the reverse direction\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalEnd, modifiedEnd)\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                }\n                else {\n                    originalIndex = reversePoints[diagonal - 1];\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n                // Save the current originalIndex so we can test for false overlap\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // as long as the elements are equal.\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n                    originalIndex--;\n                    modifiedIndex--;\n                }\n                reversePoints[diagonal] = originalIndex;\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n                // and diagonal is in the range of forward diagonals computed for numDifferences\n                // then check for overlap.\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n                    if (originalIndex <= forwardPoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Save current vectors to history before the next iteration\n            if (numDifferences <= 1447 /* MaxDifferencesHistory */) {\n                // We are allocating space for one extra int, which we fill with\n                // the index of the diagonal base index\n                let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n                MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n                this.m_forwardHistory.push(temp);\n                temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n                MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n                this.m_reverseHistory.push(temp);\n            }\n        }\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\n        // NOTE: This part is a bit messy\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n    }\n    /**\n     * Shifts the given changes to provide a more intuitive diff.\n     * While the first element in a diff matches the first element after the diff,\n     * we shift the diff down.\n     *\n     * @param changes The list of changes to shift\n     * @returns The shifted changes\n     */\n    PrettifyChanges(changes) {\n        // Shift all the changes down first\n        for (let i = 0; i < changes.length; i++) {\n            const change = changes[i];\n            const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;\n            const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            while (change.originalStart + change.originalLength < originalStop\n                && change.modifiedStart + change.modifiedLength < modifiedStop\n                && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength))\n                && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n                const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);\n                const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);\n                if (endStrictEqual && !startStrictEqual) {\n                    // moving the change down would create an equal change, but the elements are not strict equal\n                    break;\n                }\n                change.originalStart++;\n                change.modifiedStart++;\n            }\n            let mergedChangeArr = [null];\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n                changes[i] = mergedChangeArr[0];\n                changes.splice(i + 1, 1);\n                i--;\n                continue;\n            }\n        }\n        // Shift changes back up until we hit empty or whitespace-only lines\n        for (let i = changes.length - 1; i >= 0; i--) {\n            const change = changes[i];\n            let originalStop = 0;\n            let modifiedStop = 0;\n            if (i > 0) {\n                const prevChange = changes[i - 1];\n                originalStop = prevChange.originalStart + prevChange.originalLength;\n                modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n            }\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            let bestDelta = 0;\n            let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n            for (let delta = 1;; delta++) {\n                const originalStart = change.originalStart - delta;\n                const modifiedStart = change.modifiedStart - delta;\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\n                    break;\n                }\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n                    break;\n                }\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n                    break;\n                }\n                const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop);\n                const score = ((touchingPreviousChange ? 5 : 0)\n                    + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength));\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestDelta = delta;\n                }\n            }\n            change.originalStart -= bestDelta;\n            change.modifiedStart -= bestDelta;\n            const mergedChangeArr = [null];\n            if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) {\n                changes[i - 1] = mergedChangeArr[0];\n                changes.splice(i, 1);\n                i++;\n                continue;\n            }\n        }\n        // There could be multiple longest common substrings.\n        // Give preference to the ones containing longer lines\n        if (this._hasStrings) {\n            for (let i = 1, len = changes.length; i < len; i++) {\n                const aChange = changes[i - 1];\n                const bChange = changes[i];\n                const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;\n                const aOriginalStart = aChange.originalStart;\n                const bOriginalEnd = bChange.originalStart + bChange.originalLength;\n                const abOriginalLength = bOriginalEnd - aOriginalStart;\n                const aModifiedStart = aChange.modifiedStart;\n                const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;\n                const abModifiedLength = bModifiedEnd - aModifiedStart;\n                // Avoid wasting a lot of time with these searches\n                if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {\n                    const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);\n                    if (t) {\n                        const [originalMatchStart, modifiedMatchStart] = t;\n                        if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {\n                            // switch to another sequence that has a better score\n                            aChange.originalLength = originalMatchStart - aChange.originalStart;\n                            aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;\n                            bChange.originalStart = originalMatchStart + matchedLength;\n                            bChange.modifiedStart = modifiedMatchStart + matchedLength;\n                            bChange.originalLength = bOriginalEnd - bChange.originalStart;\n                            bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;\n                        }\n                    }\n                }\n            }\n        }\n        return changes;\n    }\n    _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {\n        if (originalLength < desiredLength || modifiedLength < desiredLength) {\n            return null;\n        }\n        const originalMax = originalStart + originalLength - desiredLength + 1;\n        const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;\n        let bestScore = 0;\n        let bestOriginalStart = 0;\n        let bestModifiedStart = 0;\n        for (let i = originalStart; i < originalMax; i++) {\n            for (let j = modifiedStart; j < modifiedMax; j++) {\n                const score = this._contiguousSequenceScore(i, j, desiredLength);\n                if (score > 0 && score > bestScore) {\n                    bestScore = score;\n                    bestOriginalStart = i;\n                    bestModifiedStart = j;\n                }\n            }\n        }\n        if (bestScore > 0) {\n            return [bestOriginalStart, bestModifiedStart];\n        }\n        return null;\n    }\n    _contiguousSequenceScore(originalStart, modifiedStart, length) {\n        let score = 0;\n        for (let l = 0; l < length; l++) {\n            if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {\n                return 0;\n            }\n            score += this._originalStringElements[originalStart + l].length;\n        }\n        return score;\n    }\n    _OriginalIsBoundary(index) {\n        if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._originalStringElements[index]));\n    }\n    _OriginalRegionIsBoundary(originalStart, originalLength) {\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n            return true;\n        }\n        if (originalLength > 0) {\n            const originalEnd = originalStart + originalLength;\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _ModifiedIsBoundary(index) {\n        if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._modifiedStringElements[index]));\n    }\n    _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n            return true;\n        }\n        if (modifiedLength > 0) {\n            const modifiedEnd = modifiedStart + modifiedLength;\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {\n        const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n        const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n        return (originalScore + modifiedScore);\n    }\n    /**\n     * Concatenates the two input DiffChange lists and returns the resulting\n     * list.\n     * @param The left changes\n     * @param The right changes\n     * @returns The concatenated list\n     */\n    ConcatenateChanges(left, right) {\n        let mergedChangeArr = [];\n        if (left.length === 0 || right.length === 0) {\n            return (right.length > 0) ? right : left;\n        }\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n            // Since we break the problem down recursively, it is possible that we\n            // might recurse in the middle of a change thereby splitting it into\n            // two changes. Here in the combining stage, we detect and fuse those\n            // changes back together\n            const result = new Array(left.length + right.length - 1);\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\n            result[left.length - 1] = mergedChangeArr[0];\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\n            return result;\n        }\n        else {\n            const result = new Array(left.length + right.length);\n            MyArray.Copy(left, 0, result, 0, left.length);\n            MyArray.Copy(right, 0, result, left.length, right.length);\n            return result;\n        }\n    }\n    /**\n     * Returns true if the two changes overlap and can be merged into a single\n     * change\n     * @param left The left change\n     * @param right The right change\n     * @param mergedChange The merged change if the two overlap, null otherwise\n     * @returns True if the two changes overlap\n     */\n    ChangesOverlap(left, right, mergedChangeArr) {\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n            const originalStart = left.originalStart;\n            let originalLength = left.originalLength;\n            const modifiedStart = left.modifiedStart;\n            let modifiedLength = left.modifiedLength;\n            if (left.originalStart + left.originalLength >= right.originalStart) {\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\n            }\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n            }\n            mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n            return true;\n        }\n        else {\n            mergedChangeArr[0] = null;\n            return false;\n        }\n    }\n    /**\n     * Helper method used to clip a diagonal index to the range of valid\n     * diagonals. This also decides whether or not the diagonal index,\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\n     * one inside the boundary depending on the Even/Odd status of the boundary\n     * and numDifferences.\n     * @param diagonal The index of the diagonal to clip.\n     * @param numDifferences The current number of differences being iterated upon.\n     * @param diagonalBaseIndex The base reference diagonal.\n     * @param numDiagonals The total number of diagonals.\n     * @returns The clipped diagonal index.\n     */\n    ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n        if (diagonal >= 0 && diagonal < numDiagonals) {\n            // Nothing to clip, its in range\n            return diagonal;\n        }\n        // diagonalsBelow: The number of diagonals below the reference diagonal\n        // diagonalsAbove: The number of diagonals above the reference diagonal\n        const diagonalsBelow = diagonalBaseIndex;\n        const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n        const diffEven = (numDifferences % 2 === 0);\n        if (diagonal < 0) {\n            const lowerBoundEven = (diagonalsBelow % 2 === 0);\n            return (diffEven === lowerBoundEven) ? 0 : 1;\n        }\n        else {\n            const upperBoundEven = (diagonalsAbove % 2 === 0);\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace\n// Copied from: https://github.com/nodejs/node/blob/v14.16.0/lib/path.js\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 */\nimport * as process from './process.js';\nconst CHAR_UPPERCASE_A = 65; /* A */\nconst CHAR_LOWERCASE_A = 97; /* a */\nconst CHAR_UPPERCASE_Z = 90; /* Z */\nconst CHAR_LOWERCASE_Z = 122; /* z */\nconst CHAR_DOT = 46; /* . */\nconst CHAR_FORWARD_SLASH = 47; /* / */\nconst CHAR_BACKWARD_SLASH = 92; /* \\ */\nconst CHAR_COLON = 58; /* : */\nconst CHAR_QUESTION_MARK = 63; /* ? */\nclass ErrorInvalidArgType extends Error {\n    constructor(name, expected, actual) {\n        // determiner: 'must be' or 'must not be'\n        let determiner;\n        if (typeof expected === 'string' && expected.indexOf('not ') === 0) {\n            determiner = 'must not be';\n            expected = expected.replace(/^not /, '');\n        }\n        else {\n            determiner = 'must be';\n        }\n        const type = name.indexOf('.') !== -1 ? 'property' : 'argument';\n        let msg = `The \"${name}\" ${type} ${determiner} of type ${expected}`;\n        msg += `. Received type ${typeof actual}`;\n        super(msg);\n        this.code = 'ERR_INVALID_ARG_TYPE';\n    }\n}\nfunction validateString(value, name) {\n    if (typeof value !== 'string') {\n        throw new ErrorInvalidArgType(name, 'string', value);\n    }\n}\nfunction isPathSeparator(code) {\n    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n}\nfunction isPosixPathSeparator(code) {\n    return code === CHAR_FORWARD_SLASH;\n}\nfunction isWindowsDeviceRoot(code) {\n    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||\n        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);\n}\n// Resolves . and .. elements in a path with directory names\nfunction normalizeString(path, allowAboveRoot, separator, isPathSeparator) {\n    let res = '';\n    let lastSegmentLength = 0;\n    let lastSlash = -1;\n    let dots = 0;\n    let code = 0;\n    for (let i = 0; i <= path.length; ++i) {\n        if (i < path.length) {\n            code = path.charCodeAt(i);\n        }\n        else if (isPathSeparator(code)) {\n            break;\n        }\n        else {\n            code = CHAR_FORWARD_SLASH;\n        }\n        if (isPathSeparator(code)) {\n            if (lastSlash === i - 1 || dots === 1) {\n                // NOOP\n            }\n            else if (dots === 2) {\n                if (res.length < 2 || lastSegmentLength !== 2 ||\n                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {\n                    if (res.length > 2) {\n                        const lastSlashIndex = res.lastIndexOf(separator);\n                        if (lastSlashIndex === -1) {\n                            res = '';\n                            lastSegmentLength = 0;\n                        }\n                        else {\n                            res = res.slice(0, lastSlashIndex);\n                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n                        }\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                    else if (res.length !== 0) {\n                        res = '';\n                        lastSegmentLength = 0;\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                }\n                if (allowAboveRoot) {\n                    res += res.length > 0 ? `${separator}..` : '..';\n                    lastSegmentLength = 2;\n                }\n            }\n            else {\n                if (res.length > 0) {\n                    res += `${separator}${path.slice(lastSlash + 1, i)}`;\n                }\n                else {\n                    res = path.slice(lastSlash + 1, i);\n                }\n                lastSegmentLength = i - lastSlash - 1;\n            }\n            lastSlash = i;\n            dots = 0;\n        }\n        else if (code === CHAR_DOT && dots !== -1) {\n            ++dots;\n        }\n        else {\n            dots = -1;\n        }\n    }\n    return res;\n}\nfunction _format(sep, pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n        throw new ErrorInvalidArgType('pathObject', 'Object', pathObject);\n    }\n    const dir = pathObject.dir || pathObject.root;\n    const base = pathObject.base ||\n        `${pathObject.name || ''}${pathObject.ext || ''}`;\n    if (!dir) {\n        return base;\n    }\n    return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;\n}\nexport const win32 = {\n    // path.resolve([from ...], to)\n    resolve(...pathSegments) {\n        let resolvedDevice = '';\n        let resolvedTail = '';\n        let resolvedAbsolute = false;\n        for (let i = pathSegments.length - 1; i >= -1; i--) {\n            let path;\n            if (i >= 0) {\n                path = pathSegments[i];\n                validateString(path, 'path');\n                // Skip empty entries\n                if (path.length === 0) {\n                    continue;\n                }\n            }\n            else if (resolvedDevice.length === 0) {\n                path = process.cwd();\n            }\n            else {\n                // Windows has the concept of drive-specific current working\n                // directories. If we've resolved a drive letter but not yet an\n                // absolute path, get cwd for that drive, or the process cwd if\n                // the drive cwd is not available. We're sure the device is not\n                // a UNC path at this points, because UNC paths are always absolute.\n                path = process.env[`=${resolvedDevice}`] || process.cwd();\n                // Verify that a cwd was found and that it actually points\n                // to our drive. If not, default to the drive's root.\n                if (path === undefined ||\n                    (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&\n                        path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {\n                    path = `${resolvedDevice}\\\\`;\n                }\n            }\n            const len = path.length;\n            let rootEnd = 0;\n            let device = '';\n            let isAbsolute = false;\n            const code = path.charCodeAt(0);\n            // Try to match a root\n            if (len === 1) {\n                if (isPathSeparator(code)) {\n                    // `path` contains just a path separator\n                    rootEnd = 1;\n                    isAbsolute = true;\n                }\n            }\n            else if (isPathSeparator(code)) {\n                // Possible UNC root\n                // If we started with a separator, we know we at least have an\n                // absolute path of some kind (UNC or otherwise)\n                isAbsolute = true;\n                if (isPathSeparator(path.charCodeAt(1))) {\n                    // Matched double path separator at beginning\n                    let j = 2;\n                    let last = j;\n                    // Match 1 or more non-path separators\n                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        const firstPart = path.slice(last, j);\n                        // Matched!\n                        last = j;\n                        // Match 1 or more path separators\n                        while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j < len && j !== last) {\n                            // Matched!\n                            last = j;\n                            // Match 1 or more non-path separators\n                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                                j++;\n                            }\n                            if (j === len || j !== last) {\n                                // We matched a UNC root\n                                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                                rootEnd = j;\n                            }\n                        }\n                    }\n                }\n                else {\n                    rootEnd = 1;\n                }\n            }\n            else if (isWindowsDeviceRoot(code) &&\n                path.charCodeAt(1) === CHAR_COLON) {\n                // Possible device root\n                device = path.slice(0, 2);\n                rootEnd = 2;\n                if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n                    // Treat separator following drive name as an absolute path\n                    // indicator\n                    isAbsolute = true;\n                    rootEnd = 3;\n                }\n            }\n            if (device.length > 0) {\n                if (resolvedDevice.length > 0) {\n                    if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {\n                        // This path points to another device so it is not applicable\n                        continue;\n                    }\n                }\n                else {\n                    resolvedDevice = device;\n                }\n            }\n            if (resolvedAbsolute) {\n                if (resolvedDevice.length > 0) {\n                    break;\n                }\n            }\n            else {\n                resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n                resolvedAbsolute = isAbsolute;\n                if (isAbsolute && resolvedDevice.length > 0) {\n                    break;\n                }\n            }\n        }\n        // At this point the path should be resolved to a full absolute path,\n        // but handle relative paths to be safe (might happen when process.cwd()\n        // fails)\n        // Normalize the tail path\n        resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\\\', isPathSeparator);\n        return resolvedAbsolute ?\n            `${resolvedDevice}\\\\${resolvedTail}` :\n            `${resolvedDevice}${resolvedTail}` || '.';\n    },\n    normalize(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return '.';\n        }\n        let rootEnd = 0;\n        let device;\n        let isAbsolute = false;\n        const code = path.charCodeAt(0);\n        // Try to match a root\n        if (len === 1) {\n            // `path` contains just a single char, exit early to avoid\n            // unnecessary work\n            return isPosixPathSeparator(code) ? '\\\\' : path;\n        }\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            // If we started with a separator, we know we at least have an absolute\n            // path of some kind (UNC or otherwise)\n            isAbsolute = true;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    const firstPart = path.slice(last, j);\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            // Return the normalized version of the UNC root since there\n                            // is nothing left to process\n                            return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n                        }\n                        if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                            rootEnd = j;\n                        }\n                    }\n                }\n            }\n            else {\n                rootEnd = 1;\n            }\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            // Possible device root\n            device = path.slice(0, 2);\n            rootEnd = 2;\n            if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n                // Treat separator following drive name as an absolute path\n                // indicator\n                isAbsolute = true;\n                rootEnd = 3;\n            }\n        }\n        let tail = rootEnd < len ?\n            normalizeString(path.slice(rootEnd), !isAbsolute, '\\\\', isPathSeparator) :\n            '';\n        if (tail.length === 0 && !isAbsolute) {\n            tail = '.';\n        }\n        if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n            tail += '\\\\';\n        }\n        if (device === undefined) {\n            return isAbsolute ? `\\\\${tail}` : tail;\n        }\n        return isAbsolute ? `${device}\\\\${tail}` : `${device}${tail}`;\n    },\n    isAbsolute(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return false;\n        }\n        const code = path.charCodeAt(0);\n        return isPathSeparator(code) ||\n            // Possible device root\n            (len > 2 &&\n                isWindowsDeviceRoot(code) &&\n                path.charCodeAt(1) === CHAR_COLON &&\n                isPathSeparator(path.charCodeAt(2)));\n    },\n    join(...paths) {\n        if (paths.length === 0) {\n            return '.';\n        }\n        let joined;\n        let firstPart;\n        for (let i = 0; i < paths.length; ++i) {\n            const arg = paths[i];\n            validateString(arg, 'path');\n            if (arg.length > 0) {\n                if (joined === undefined) {\n                    joined = firstPart = arg;\n                }\n                else {\n                    joined += `\\\\${arg}`;\n                }\n            }\n        }\n        if (joined === undefined) {\n            return '.';\n        }\n        // Make sure that the joined path doesn't start with two slashes, because\n        // normalize() will mistake it for a UNC path then.\n        //\n        // This step is skipped when it is very clear that the user actually\n        // intended to point at a UNC path. This is assumed when the first\n        // non-empty string arguments starts with exactly two slashes followed by\n        // at least one more non-slash character.\n        //\n        // Note that for normalize() to treat a path as a UNC path it needs to\n        // have at least 2 components, so we don't filter for that here.\n        // This means that the user can use join to construct UNC paths from\n        // a server name and a share name; for example:\n        //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n        let needsReplace = true;\n        let slashCount = 0;\n        if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) {\n            ++slashCount;\n            const firstLen = firstPart.length;\n            if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {\n                ++slashCount;\n                if (firstLen > 2) {\n                    if (isPathSeparator(firstPart.charCodeAt(2))) {\n                        ++slashCount;\n                    }\n                    else {\n                        // We matched a UNC path in the first part\n                        needsReplace = false;\n                    }\n                }\n            }\n        }\n        if (needsReplace) {\n            // Find any more consecutive slashes we need to replace\n            while (slashCount < joined.length &&\n                isPathSeparator(joined.charCodeAt(slashCount))) {\n                slashCount++;\n            }\n            // Replace the slashes if needed\n            if (slashCount >= 2) {\n                joined = `\\\\${joined.slice(slashCount)}`;\n            }\n        }\n        return win32.normalize(joined);\n    },\n    // It will solve the relative path from `from` to `to`, for instance:\n    //  from = 'C:\\\\orandea\\\\test\\\\aaa'\n    //  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n    // The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n    relative(from, to) {\n        validateString(from, 'from');\n        validateString(to, 'to');\n        if (from === to) {\n            return '';\n        }\n        const fromOrig = win32.resolve(from);\n        const toOrig = win32.resolve(to);\n        if (fromOrig === toOrig) {\n            return '';\n        }\n        from = fromOrig.toLowerCase();\n        to = toOrig.toLowerCase();\n        if (from === to) {\n            return '';\n        }\n        // Trim any leading backslashes\n        let fromStart = 0;\n        while (fromStart < from.length &&\n            from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {\n            fromStart++;\n        }\n        // Trim trailing backslashes (applicable to UNC paths only)\n        let fromEnd = from.length;\n        while (fromEnd - 1 > fromStart &&\n            from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {\n            fromEnd--;\n        }\n        const fromLen = fromEnd - fromStart;\n        // Trim any leading backslashes\n        let toStart = 0;\n        while (toStart < to.length &&\n            to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n            toStart++;\n        }\n        // Trim trailing backslashes (applicable to UNC paths only)\n        let toEnd = to.length;\n        while (toEnd - 1 > toStart &&\n            to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {\n            toEnd--;\n        }\n        const toLen = toEnd - toStart;\n        // Compare paths to find the longest common path from root\n        const length = fromLen < toLen ? fromLen : toLen;\n        let lastCommonSep = -1;\n        let i = 0;\n        for (; i < length; i++) {\n            const fromCode = from.charCodeAt(fromStart + i);\n            if (fromCode !== to.charCodeAt(toStart + i)) {\n                break;\n            }\n            else if (fromCode === CHAR_BACKWARD_SLASH) {\n                lastCommonSep = i;\n            }\n        }\n        // We found a mismatch before the first common path separator was seen, so\n        // return the original `to`.\n        if (i !== length) {\n            if (lastCommonSep === -1) {\n                return toOrig;\n            }\n        }\n        else {\n            if (toLen > length) {\n                if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n                    // We get here if `from` is the exact base path for `to`.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n                    return toOrig.slice(toStart + i + 1);\n                }\n                if (i === 2) {\n                    // We get here if `from` is the device root.\n                    // For example: from='C:\\\\'; to='C:\\\\foo'\n                    return toOrig.slice(toStart + i);\n                }\n            }\n            if (fromLen > length) {\n                if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n                    // We get here if `to` is the exact base path for `from`.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n                    lastCommonSep = i;\n                }\n                else if (i === 2) {\n                    // We get here if `to` is the device root.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n                    lastCommonSep = 3;\n                }\n            }\n            if (lastCommonSep === -1) {\n                lastCommonSep = 0;\n            }\n        }\n        let out = '';\n        // Generate the relative path based on the path difference between `to` and\n        // `from`\n        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n            if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n                out += out.length === 0 ? '..' : '\\\\..';\n            }\n        }\n        toStart += lastCommonSep;\n        // Lastly, append the rest of the destination (`to`) path that comes after\n        // the common path parts\n        if (out.length > 0) {\n            return `${out}${toOrig.slice(toStart, toEnd)}`;\n        }\n        if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n            ++toStart;\n        }\n        return toOrig.slice(toStart, toEnd);\n    },\n    toNamespacedPath(path) {\n        // Note: this will *probably* throw somewhere.\n        if (typeof path !== 'string') {\n            return path;\n        }\n        if (path.length === 0) {\n            return '';\n        }\n        const resolvedPath = win32.resolve(path);\n        if (resolvedPath.length <= 2) {\n            return path;\n        }\n        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n            // Possible UNC root\n            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n                const code = resolvedPath.charCodeAt(2);\n                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n                    // Matched non-long UNC root, convert the path to a long UNC path\n                    return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n                }\n            }\n        }\n        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&\n            resolvedPath.charCodeAt(1) === CHAR_COLON &&\n            resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {\n            // Matched device root, convert the path to a long UNC path\n            return `\\\\\\\\?\\\\${resolvedPath}`;\n        }\n        return path;\n    },\n    dirname(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return '.';\n        }\n        let rootEnd = -1;\n        let offset = 0;\n        const code = path.charCodeAt(0);\n        if (len === 1) {\n            // `path` contains just a path separator, exit early to avoid\n            // unnecessary work or a dot.\n            return isPathSeparator(code) ? path : '.';\n        }\n        // Try to match a root\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            rootEnd = offset = 1;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            return path;\n                        }\n                        if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            // Offset by 1 to include the separator after the UNC root to\n                            // treat it as a \"normal root\" on top of a (UNC) root\n                            rootEnd = offset = j + 1;\n                        }\n                    }\n                }\n            }\n            // Possible device root\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;\n            offset = rootEnd;\n        }\n        let end = -1;\n        let matchedSlash = true;\n        for (let i = len - 1; i >= offset; --i) {\n            if (isPathSeparator(path.charCodeAt(i))) {\n                if (!matchedSlash) {\n                    end = i;\n                    break;\n                }\n            }\n            else {\n                // We saw the first non-path separator\n                matchedSlash = false;\n            }\n        }\n        if (end === -1) {\n            if (rootEnd === -1) {\n                return '.';\n            }\n            end = rootEnd;\n        }\n        return path.slice(0, end);\n    },\n    basename(path, ext) {\n        if (ext !== undefined) {\n            validateString(ext, 'ext');\n        }\n        validateString(path, 'path');\n        let start = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i;\n        // Check for a drive letter prefix so as not to mistake the following\n        // path separator as an extra separator at the end of the path that can be\n        // disregarded\n        if (path.length >= 2 &&\n            isWindowsDeviceRoot(path.charCodeAt(0)) &&\n            path.charCodeAt(1) === CHAR_COLON) {\n            start = 2;\n        }\n        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n            if (ext === path) {\n                return '';\n            }\n            let extIdx = ext.length - 1;\n            let firstNonSlashEnd = -1;\n            for (i = path.length - 1; i >= start; --i) {\n                const code = path.charCodeAt(i);\n                if (isPathSeparator(code)) {\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                }\n                else {\n                    if (firstNonSlashEnd === -1) {\n                        // We saw the first non-path separator, remember this index in case\n                        // we need it if the extension ends up not matching\n                        matchedSlash = false;\n                        firstNonSlashEnd = i + 1;\n                    }\n                    if (extIdx >= 0) {\n                        // Try to match the explicit extension\n                        if (code === ext.charCodeAt(extIdx)) {\n                            if (--extIdx === -1) {\n                                // We matched the extension, so mark this as the end of our path\n                                // component\n                                end = i;\n                            }\n                        }\n                        else {\n                            // Extension does not match, so our result is the entire path\n                            // component\n                            extIdx = -1;\n                            end = firstNonSlashEnd;\n                        }\n                    }\n                }\n            }\n            if (start === end) {\n                end = firstNonSlashEnd;\n            }\n            else if (end === -1) {\n                end = path.length;\n            }\n            return path.slice(start, end);\n        }\n        for (i = path.length - 1; i >= start; --i) {\n            if (isPathSeparator(path.charCodeAt(i))) {\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            }\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        if (end === -1) {\n            return '';\n        }\n        return path.slice(start, end);\n    },\n    extname(path) {\n        validateString(path, 'path');\n        let start = 0;\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let 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        let preDotState = 0;\n        // Check for a drive letter prefix so as not to mistake the following\n        // path separator as an extra separator at the end of the path that can be\n        // disregarded\n        if (path.length >= 2 &&\n            path.charCodeAt(1) === CHAR_COLON &&\n            isWindowsDeviceRoot(path.charCodeAt(0))) {\n            start = startPart = 2;\n        }\n        for (let i = path.length - 1; i >= start; --i) {\n            const code = path.charCodeAt(i);\n            if (isPathSeparator(code)) {\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 === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\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        if (startDot === -1 ||\n            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 &&\n                startDot === end - 1 &&\n                startDot === startPart + 1)) {\n            return '';\n        }\n        return path.slice(startDot, end);\n    },\n    format: _format.bind(null, '\\\\'),\n    parse(path) {\n        validateString(path, 'path');\n        const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n        if (path.length === 0) {\n            return ret;\n        }\n        const len = path.length;\n        let rootEnd = 0;\n        let code = path.charCodeAt(0);\n        if (len === 1) {\n            if (isPathSeparator(code)) {\n                // `path` contains just a path separator, exit early to avoid\n                // unnecessary work\n                ret.root = ret.dir = path;\n                return ret;\n            }\n            ret.base = ret.name = path;\n            return ret;\n        }\n        // Try to match a root\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            rootEnd = 1;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            rootEnd = j;\n                        }\n                        else if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            rootEnd = j + 1;\n                        }\n                    }\n                }\n            }\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            // Possible device root\n            if (len <= 2) {\n                // `path` contains just a drive root, exit early to avoid\n                // unnecessary work\n                ret.root = ret.dir = path;\n                return ret;\n            }\n            rootEnd = 2;\n            if (isPathSeparator(path.charCodeAt(2))) {\n                if (len === 3) {\n                    // `path` contains just a drive root, exit early to avoid\n                    // unnecessary work\n                    ret.root = ret.dir = path;\n                    return ret;\n                }\n                rootEnd = 3;\n            }\n        }\n        if (rootEnd > 0) {\n            ret.root = path.slice(0, rootEnd);\n        }\n        let startDot = -1;\n        let startPart = rootEnd;\n        let end = -1;\n        let matchedSlash = true;\n        let i = path.length - 1;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        // Get non-dir info\n        for (; i >= rootEnd; --i) {\n            code = path.charCodeAt(i);\n            if (isPathSeparator(code)) {\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 === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\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        if (end !== -1) {\n            if (startDot === -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 &&\n                    startDot === end - 1 &&\n                    startDot === startPart + 1)) {\n                ret.base = ret.name = path.slice(startPart, end);\n            }\n            else {\n                ret.name = path.slice(startPart, startDot);\n                ret.base = path.slice(startPart, end);\n                ret.ext = path.slice(startDot, end);\n            }\n        }\n        // If the directory is the root, use the entire root as the `dir` including\n        // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n        // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n        if (startPart > 0 && startPart !== rootEnd) {\n            ret.dir = path.slice(0, startPart - 1);\n        }\n        else {\n            ret.dir = ret.root;\n        }\n        return ret;\n    },\n    sep: '\\\\',\n    delimiter: ';',\n    win32: null,\n    posix: null\n};\nexport const posix = {\n    // path.resolve([from ...], to)\n    resolve(...pathSegments) {\n        let resolvedPath = '';\n        let resolvedAbsolute = false;\n        for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n            const path = i >= 0 ? pathSegments[i] : process.cwd();\n            validateString(path, 'path');\n            // Skip empty entries\n            if (path.length === 0) {\n                continue;\n            }\n            resolvedPath = `${path}/${resolvedPath}`;\n            resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\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        // Normalize the path\n        resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);\n        if (resolvedAbsolute) {\n            return `/${resolvedPath}`;\n        }\n        return resolvedPath.length > 0 ? resolvedPath : '.';\n    },\n    normalize(path) {\n        validateString(path, 'path');\n        if (path.length === 0) {\n            return '.';\n        }\n        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n        // Normalize the path\n        path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);\n        if (path.length === 0) {\n            if (isAbsolute) {\n                return '/';\n            }\n            return trailingSeparator ? './' : '.';\n        }\n        if (trailingSeparator) {\n            path += '/';\n        }\n        return isAbsolute ? `/${path}` : path;\n    },\n    isAbsolute(path) {\n        validateString(path, 'path');\n        return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n    },\n    join(...paths) {\n        if (paths.length === 0) {\n            return '.';\n        }\n        let joined;\n        for (let i = 0; i < paths.length; ++i) {\n            const arg = paths[i];\n            validateString(arg, 'path');\n            if (arg.length > 0) {\n                if (joined === undefined) {\n                    joined = arg;\n                }\n                else {\n                    joined += `/${arg}`;\n                }\n            }\n        }\n        if (joined === undefined) {\n            return '.';\n        }\n        return posix.normalize(joined);\n    },\n    relative(from, to) {\n        validateString(from, 'from');\n        validateString(to, 'to');\n        if (from === to) {\n            return '';\n        }\n        // Trim leading forward slashes.\n        from = posix.resolve(from);\n        to = posix.resolve(to);\n        if (from === to) {\n            return '';\n        }\n        const fromStart = 1;\n        const fromEnd = from.length;\n        const fromLen = fromEnd - fromStart;\n        const toStart = 1;\n        const toLen = to.length - toStart;\n        // Compare paths to find the longest common path from root\n        const length = (fromLen < toLen ? fromLen : toLen);\n        let lastCommonSep = -1;\n        let i = 0;\n        for (; i < length; i++) {\n            const fromCode = from.charCodeAt(fromStart + i);\n            if (fromCode !== to.charCodeAt(toStart + i)) {\n                break;\n            }\n            else if (fromCode === CHAR_FORWARD_SLASH) {\n                lastCommonSep = i;\n            }\n        }\n        if (i === length) {\n            if (toLen > length) {\n                if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n                    // We get here if `from` is the exact base path for `to`.\n                    // For example: from='/foo/bar'; to='/foo/bar/baz'\n                    return to.slice(toStart + i + 1);\n                }\n                if (i === 0) {\n                    // We get here if `from` is the root\n                    // For example: from='/'; to='/foo'\n                    return to.slice(toStart + i);\n                }\n            }\n            else if (fromLen > length) {\n                if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n                    // We get here if `to` is the exact base path for `from`.\n                    // For example: from='/foo/bar/baz'; to='/foo/bar'\n                    lastCommonSep = i;\n                }\n                else if (i === 0) {\n                    // We get here if `to` is the root.\n                    // For example: from='/foo/bar'; to='/'\n                    lastCommonSep = 0;\n                }\n            }\n        }\n        let out = '';\n        // Generate the relative path based on the path difference between `to`\n        // and `from`.\n        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n            if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n                out += out.length === 0 ? '..' : '/..';\n            }\n        }\n        // Lastly, append the rest of the destination (`to`) path that comes after\n        // the common path parts.\n        return `${out}${to.slice(toStart + lastCommonSep)}`;\n    },\n    toNamespacedPath(path) {\n        // Non-op on posix systems\n        return path;\n    },\n    dirname(path) {\n        validateString(path, 'path');\n        if (path.length === 0) {\n            return '.';\n        }\n        const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        let end = -1;\n        let matchedSlash = true;\n        for (let i = path.length - 1; i >= 1; --i) {\n            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n                if (!matchedSlash) {\n                    end = i;\n                    break;\n                }\n            }\n            else {\n                // We saw the first non-path separator\n                matchedSlash = false;\n            }\n        }\n        if (end === -1) {\n            return hasRoot ? '/' : '.';\n        }\n        if (hasRoot && end === 1) {\n            return '//';\n        }\n        return path.slice(0, end);\n    },\n    basename(path, ext) {\n        if (ext !== undefined) {\n            validateString(ext, 'ext');\n        }\n        validateString(path, 'path');\n        let start = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i;\n        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n            if (ext === path) {\n                return '';\n            }\n            let extIdx = ext.length - 1;\n            let firstNonSlashEnd = -1;\n            for (i = path.length - 1; i >= 0; --i) {\n                const code = path.charCodeAt(i);\n                if (code === CHAR_FORWARD_SLASH) {\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                }\n                else {\n                    if (firstNonSlashEnd === -1) {\n                        // We saw the first non-path separator, remember this index in case\n                        // we need it if the extension ends up not matching\n                        matchedSlash = false;\n                        firstNonSlashEnd = i + 1;\n                    }\n                    if (extIdx >= 0) {\n                        // Try to match the explicit extension\n                        if (code === ext.charCodeAt(extIdx)) {\n                            if (--extIdx === -1) {\n                                // We matched the extension, so mark this as the end of our path\n                                // component\n                                end = i;\n                            }\n                        }\n                        else {\n                            // Extension does not match, so our result is the entire path\n                            // component\n                            extIdx = -1;\n                            end = firstNonSlashEnd;\n                        }\n                    }\n                }\n            }\n            if (start === end) {\n                end = firstNonSlashEnd;\n            }\n            else if (end === -1) {\n                end = path.length;\n            }\n            return path.slice(start, end);\n        }\n        for (i = path.length - 1; i >= 0; --i) {\n            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\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            }\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        if (end === -1) {\n            return '';\n        }\n        return path.slice(start, end);\n    },\n    extname(path) {\n        validateString(path, 'path');\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let 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        let preDotState = 0;\n        for (let i = path.length - 1; i >= 0; --i) {\n            const code = path.charCodeAt(i);\n            if (code === CHAR_FORWARD_SLASH) {\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 === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\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        if (startDot === -1 ||\n            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 &&\n                startDot === end - 1 &&\n                startDot === startPart + 1)) {\n            return '';\n        }\n        return path.slice(startDot, end);\n    },\n    format: _format.bind(null, '/'),\n    parse(path) {\n        validateString(path, 'path');\n        const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n        if (path.length === 0) {\n            return ret;\n        }\n        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        let start;\n        if (isAbsolute) {\n            ret.root = '/';\n            start = 1;\n        }\n        else {\n            start = 0;\n        }\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i = path.length - 1;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        // Get non-dir info\n        for (; i >= start; --i) {\n            const code = path.charCodeAt(i);\n            if (code === CHAR_FORWARD_SLASH) {\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 === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\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        if (end !== -1) {\n            const start = startPart === 0 && isAbsolute ? 1 : startPart;\n            if (startDot === -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 &&\n                    startDot === end - 1 &&\n                    startDot === startPart + 1)) {\n                ret.base = ret.name = path.slice(start, end);\n            }\n            else {\n                ret.name = path.slice(start, startDot);\n                ret.base = path.slice(start, end);\n                ret.ext = path.slice(startDot, end);\n            }\n        }\n        if (startPart > 0) {\n            ret.dir = path.slice(0, startPart - 1);\n        }\n        else if (isAbsolute) {\n            ret.dir = '/';\n        }\n        return ret;\n    },\n    sep: '/',\n    delimiter: ':',\n    win32: null,\n    posix: null\n};\nposix.win32 = win32.win32 = win32;\nposix.posix = win32.posix = posix;\nexport const normalize = (process.platform === 'win32' ? win32.normalize : posix.normalize);\nexport const resolve = (process.platform === 'win32' ? win32.resolve : posix.resolve);\nexport const relative = (process.platform === 'win32' ? win32.relative : posix.relative);\nexport const dirname = (process.platform === 'win32' ? win32.dirname : posix.dirname);\nexport const basename = (process.platform === 'win32' ? win32.basename : posix.basename);\nexport const extname = (process.platform === 'win32' ? win32.extname : posix.extname);\nexport const sep = (process.platform === 'win32' ? win32.sep : posix.sep);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as paths from './path.js';\nimport { isWindows } from './platform.js';\nconst _schemePattern = /^\\w[\\w\\d+.-]*$/;\nconst _singleSlashStart = /^\\//;\nconst _doubleSlashStart = /^\\/\\//;\nfunction _validateUri(ret, _strict) {\n    // scheme, must be set\n    if (!ret.scheme && _strict) {\n        throw new Error(`[UriError]: Scheme is missing: {scheme: \"\", authority: \"${ret.authority}\", path: \"${ret.path}\", query: \"${ret.query}\", fragment: \"${ret.fragment}\"}`);\n    }\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n        throw new Error('[UriError]: Scheme contains illegal characters.');\n    }\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\n    // If a URI contains an authority component, then the path component\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\n    // does not contain an authority component, then the path cannot begin\n    // with two slash characters (\"//\").\n    if (ret.path) {\n        if (ret.authority) {\n            if (!_singleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character');\n            }\n        }\n        else {\n            if (_doubleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n            }\n        }\n    }\n}\n// for a while we allowed uris *without* schemes and this is the migration\n// for them, e.g. an uri without scheme and without strict-mode warns and falls\n// back to the file-scheme. that should cause the least carnage and still be a\n// clear warning\nfunction _schemeFix(scheme, _strict) {\n    if (!scheme && !_strict) {\n        return 'file';\n    }\n    return scheme;\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n    // the slash-character is our 'default base' as we don't\n    // support constructing URIs relative to other URIs. This\n    // also means that we alter and potentially break paths.\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n    switch (scheme) {\n        case 'https':\n        case 'http':\n        case 'file':\n            if (!path) {\n                path = _slash;\n            }\n            else if (path[0] !== _slash) {\n                path = _slash + path;\n            }\n            break;\n    }\n    return path;\n}\nconst _empty = '';\nconst _slash = '/';\nconst _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n * ```txt\n *       foo://example.com:8042/over/there?name=ferret#nose\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\n *        |           |            |            |        |\n *     scheme     authority       path        query   fragment\n *        |   _____________________|__\n *       / \\ /                        \\\n *       urn:example:animal:ferret:nose\n * ```\n */\nexport class URI {\n    /**\n     * @internal\n     */\n    constructor(schemeOrData, authority, path, query, fragment, _strict = false) {\n        if (typeof schemeOrData === 'object') {\n            this.scheme = schemeOrData.scheme || _empty;\n            this.authority = schemeOrData.authority || _empty;\n            this.path = schemeOrData.path || _empty;\n            this.query = schemeOrData.query || _empty;\n            this.fragment = schemeOrData.fragment || _empty;\n            // no validation because it's this URI\n            // that creates uri components.\n            // _validateUri(this);\n        }\n        else {\n            this.scheme = _schemeFix(schemeOrData, _strict);\n            this.authority = authority || _empty;\n            this.path = _referenceResolution(this.scheme, path || _empty);\n            this.query = query || _empty;\n            this.fragment = fragment || _empty;\n            _validateUri(this, _strict);\n        }\n    }\n    static isUri(thing) {\n        if (thing instanceof URI) {\n            return true;\n        }\n        if (!thing) {\n            return false;\n        }\n        return typeof thing.authority === 'string'\n            && typeof thing.fragment === 'string'\n            && typeof thing.path === 'string'\n            && typeof thing.query === 'string'\n            && typeof thing.scheme === 'string'\n            && typeof thing.fsPath === 'string'\n            && typeof thing.with === 'function'\n            && typeof thing.toString === 'function';\n    }\n    // ---- filesystem path -----------------------\n    /**\n     * Returns a string representing the corresponding file system path of this URI.\n     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n     * platform specific path separator.\n     *\n     * * Will *not* validate the path for invalid characters and semantics.\n     * * Will *not* look at the scheme of this URI.\n     * * The result shall *not* be used for display purposes but for accessing a file on disk.\n     *\n     *\n     * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n     *\n     * ```ts\n        const u = URI.parse('file://server/c$/folder/file.txt')\n        u.authority === 'server'\n        u.path === '/shares/c$/file.txt'\n        u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n    ```\n     *\n     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n     * with URIs that represent files on disk (`file` scheme).\n     */\n    get fsPath() {\n        // if (this.scheme !== 'file') {\n        // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n        // }\n        return uriToFsPath(this, false);\n    }\n    // ---- modify to new -------------------------\n    with(change) {\n        if (!change) {\n            return this;\n        }\n        let { scheme, authority, path, query, fragment } = change;\n        if (scheme === undefined) {\n            scheme = this.scheme;\n        }\n        else if (scheme === null) {\n            scheme = _empty;\n        }\n        if (authority === undefined) {\n            authority = this.authority;\n        }\n        else if (authority === null) {\n            authority = _empty;\n        }\n        if (path === undefined) {\n            path = this.path;\n        }\n        else if (path === null) {\n            path = _empty;\n        }\n        if (query === undefined) {\n            query = this.query;\n        }\n        else if (query === null) {\n            query = _empty;\n        }\n        if (fragment === undefined) {\n            fragment = this.fragment;\n        }\n        else if (fragment === null) {\n            fragment = _empty;\n        }\n        if (scheme === this.scheme\n            && authority === this.authority\n            && path === this.path\n            && query === this.query\n            && fragment === this.fragment) {\n            return this;\n        }\n        return new Uri(scheme, authority, path, query, fragment);\n    }\n    // ---- parse & validate ------------------------\n    /**\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\n     * `file:///usr/home`, or `scheme:with/path`.\n     *\n     * @param value A string which represents an URI (see `URI#toString`).\n     */\n    static parse(value, _strict = false) {\n        const match = _regexp.exec(value);\n        if (!match) {\n            return new Uri(_empty, _empty, _empty, _empty, _empty);\n        }\n        return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);\n    }\n    /**\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\n     *\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n     * `URI.parse('file://' + path)` because the path might contain characters that are\n     * interpreted (# and ?). See the following sample:\n     * ```ts\n    const good = URI.file('/coding/c#/project1');\n    good.scheme === 'file';\n    good.path === '/coding/c#/project1';\n    good.fragment === '';\n    const bad = URI.parse('file://' + '/coding/c#/project1');\n    bad.scheme === 'file';\n    bad.path === '/coding/c'; // path is now broken\n    bad.fragment === '/project1';\n    ```\n     *\n     * @param path A file system path (see `URI#fsPath`)\n     */\n    static file(path) {\n        let authority = _empty;\n        // normalize to fwd-slashes on windows,\n        // on other systems bwd-slashes are valid\n        // filename character, eg /f\\oo/ba\\r.txt\n        if (isWindows) {\n            path = path.replace(/\\\\/g, _slash);\n        }\n        // check for authority as used in UNC shares\n        // or use the path as given\n        if (path[0] === _slash && path[1] === _slash) {\n            const idx = path.indexOf(_slash, 2);\n            if (idx === -1) {\n                authority = path.substring(2);\n                path = _slash;\n            }\n            else {\n                authority = path.substring(2, idx);\n                path = path.substring(idx) || _slash;\n            }\n        }\n        return new Uri('file', authority, path, _empty, _empty);\n    }\n    static from(components) {\n        const result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment);\n        _validateUri(result, true);\n        return result;\n    }\n    /**\n     * Join a URI path with path fragments and normalizes the resulting path.\n     *\n     * @param uri The input URI.\n     * @param pathFragment The path fragment to add to the URI path.\n     * @returns The resulting URI.\n     */\n    static joinPath(uri, ...pathFragment) {\n        if (!uri.path) {\n            throw new Error(`[UriError]: cannot call joinPath on URI without path`);\n        }\n        let newPath;\n        if (isWindows && uri.scheme === 'file') {\n            newPath = URI.file(paths.win32.join(uriToFsPath(uri, true), ...pathFragment)).path;\n        }\n        else {\n            newPath = paths.posix.join(uri.path, ...pathFragment);\n        }\n        return uri.with({ path: newPath });\n    }\n    // ---- printing/externalize ---------------------------\n    /**\n     * Creates a string representation for this URI. It's guaranteed that calling\n     * `URI.parse` with the result of this function creates an URI which is equal\n     * to this URI.\n     *\n     * * The result shall *not* be used for display purposes but for externalization or transport.\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\n     * ignore the scheme-specific encoding rules.\n     *\n     * @param skipEncoding Do not encode the result, default is `false`\n     */\n    toString(skipEncoding = false) {\n        return _asFormatted(this, skipEncoding);\n    }\n    toJSON() {\n        return this;\n    }\n    static revive(data) {\n        if (!data) {\n            return data;\n        }\n        else if (data instanceof URI) {\n            return data;\n        }\n        else {\n            const result = new Uri(data);\n            result._formatted = data.external;\n            result._fsPath = data._sep === _pathSepMarker ? data.fsPath : null;\n            return result;\n        }\n    }\n}\nconst _pathSepMarker = isWindows ? 1 : undefined;\n// This class exists so that URI is compatible with vscode.Uri (API).\nclass Uri extends URI {\n    constructor() {\n        super(...arguments);\n        this._formatted = null;\n        this._fsPath = null;\n    }\n    get fsPath() {\n        if (!this._fsPath) {\n            this._fsPath = uriToFsPath(this, false);\n        }\n        return this._fsPath;\n    }\n    toString(skipEncoding = false) {\n        if (!skipEncoding) {\n            if (!this._formatted) {\n                this._formatted = _asFormatted(this, false);\n            }\n            return this._formatted;\n        }\n        else {\n            // we don't cache that\n            return _asFormatted(this, true);\n        }\n    }\n    toJSON() {\n        const res = {\n            $mid: 1 /* Uri */\n        };\n        // cached state\n        if (this._fsPath) {\n            res.fsPath = this._fsPath;\n            res._sep = _pathSepMarker;\n        }\n        if (this._formatted) {\n            res.external = this._formatted;\n        }\n        // uri components\n        if (this.path) {\n            res.path = this.path;\n        }\n        if (this.scheme) {\n            res.scheme = this.scheme;\n        }\n        if (this.authority) {\n            res.authority = this.authority;\n        }\n        if (this.query) {\n            res.query = this.query;\n        }\n        if (this.fragment) {\n            res.fragment = this.fragment;\n        }\n        return res;\n    }\n}\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nconst encodeTable = {\n    [58 /* Colon */]: '%3A',\n    [47 /* Slash */]: '%2F',\n    [63 /* QuestionMark */]: '%3F',\n    [35 /* Hash */]: '%23',\n    [91 /* OpenSquareBracket */]: '%5B',\n    [93 /* CloseSquareBracket */]: '%5D',\n    [64 /* AtSign */]: '%40',\n    [33 /* ExclamationMark */]: '%21',\n    [36 /* DollarSign */]: '%24',\n    [38 /* Ampersand */]: '%26',\n    [39 /* SingleQuote */]: '%27',\n    [40 /* OpenParen */]: '%28',\n    [41 /* CloseParen */]: '%29',\n    [42 /* Asterisk */]: '%2A',\n    [43 /* Plus */]: '%2B',\n    [44 /* Comma */]: '%2C',\n    [59 /* Semicolon */]: '%3B',\n    [61 /* Equals */]: '%3D',\n    [32 /* Space */]: '%20',\n};\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\n    let res = undefined;\n    let nativeEncodePos = -1;\n    for (let pos = 0; pos < uriComponent.length; pos++) {\n        const code = uriComponent.charCodeAt(pos);\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\n            || code === 45 /* Dash */\n            || code === 46 /* Period */\n            || code === 95 /* Underline */\n            || code === 126 /* Tilde */\n            || (allowSlash && code === 47 /* Slash */)) {\n            // check if we are delaying native encode\n            if (nativeEncodePos !== -1) {\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                nativeEncodePos = -1;\n            }\n            // check if we write into a new string (by default we try to return the param)\n            if (res !== undefined) {\n                res += uriComponent.charAt(pos);\n            }\n        }\n        else {\n            // encoding needed, we need to allocate a new string\n            if (res === undefined) {\n                res = uriComponent.substr(0, pos);\n            }\n            // check with default table first\n            const escaped = encodeTable[code];\n            if (escaped !== undefined) {\n                // check if we are delaying native encode\n                if (nativeEncodePos !== -1) {\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                    nativeEncodePos = -1;\n                }\n                // append escaped variant to result\n                res += escaped;\n            }\n            else if (nativeEncodePos === -1) {\n                // use native encode only when needed\n                nativeEncodePos = pos;\n            }\n        }\n    }\n    if (nativeEncodePos !== -1) {\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n    }\n    return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n    let res = undefined;\n    for (let pos = 0; pos < path.length; pos++) {\n        const code = path.charCodeAt(pos);\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\n            if (res === undefined) {\n                res = path.substr(0, pos);\n            }\n            res += encodeTable[code];\n        }\n        else {\n            if (res !== undefined) {\n                res += path[pos];\n            }\n        }\n    }\n    return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n */\nexport function uriToFsPath(uri, keepDriveLetterCasing) {\n    let value;\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n        // unc path: file://shares/c$/far/boo\n        value = `//${uri.authority}${uri.path}`;\n    }\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\n        && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */)\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\n        if (!keepDriveLetterCasing) {\n            // windows drive letter: file:///c:/far/boo\n            value = uri.path[1].toLowerCase() + uri.path.substr(2);\n        }\n        else {\n            value = uri.path.substr(1);\n        }\n    }\n    else {\n        // other path\n        value = uri.path;\n    }\n    if (isWindows) {\n        value = value.replace(/\\//g, '\\\\');\n    }\n    return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n    const encoder = !skipEncoding\n        ? encodeURIComponentFast\n        : encodeURIComponentMinimal;\n    let res = '';\n    let { scheme, authority, path, query, fragment } = uri;\n    if (scheme) {\n        res += scheme;\n        res += ':';\n    }\n    if (authority || scheme === 'file') {\n        res += _slash;\n        res += _slash;\n    }\n    if (authority) {\n        let idx = authority.indexOf('@');\n        if (idx !== -1) {\n            // <user>@<auth>\n            const userinfo = authority.substr(0, idx);\n            authority = authority.substr(idx + 1);\n            idx = userinfo.indexOf(':');\n            if (idx === -1) {\n                res += encoder(userinfo, false);\n            }\n            else {\n                // <user>:<pass>@<auth>\n                res += encoder(userinfo.substr(0, idx), false);\n                res += ':';\n                res += encoder(userinfo.substr(idx + 1), false);\n            }\n            res += '@';\n        }\n        authority = authority.toLowerCase();\n        idx = authority.indexOf(':');\n        if (idx === -1) {\n            res += encoder(authority, false);\n        }\n        else {\n            // <auth>:<port>\n            res += encoder(authority.substr(0, idx), false);\n            res += authority.substr(idx);\n        }\n    }\n    if (path) {\n        // lower-case windows drive letters in /C:/fff or C:/fff\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\n            const code = path.charCodeAt(1);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // \"/c:\".length === 3\n            }\n        }\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\n            const code = path.charCodeAt(0);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // \"/c:\".length === 3\n            }\n        }\n        // encode the rest of the path\n        res += encoder(path, true);\n    }\n    if (query) {\n        res += '?';\n        res += encoder(query, false);\n    }\n    if (fragment) {\n        res += '#';\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\n    }\n    return res;\n}\n// --- decode\nfunction decodeURIComponentGraceful(str) {\n    try {\n        return decodeURIComponent(str);\n    }\n    catch (_a) {\n        if (str.length > 3) {\n            return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));\n        }\n        else {\n            return str;\n        }\n    }\n}\nconst _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;\nfunction percentDecode(str) {\n    if (!str.match(_rEncodedAsHex)) {\n        return str;\n    }\n    return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nexport class Position {\n    constructor(lineNumber, column) {\n        this.lineNumber = lineNumber;\n        this.column = column;\n    }\n    /**\n     * Create a new position from this position.\n     *\n     * @param newLineNumber new line number\n     * @param newColumn new column\n     */\n    with(newLineNumber = this.lineNumber, newColumn = this.column) {\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\n            return this;\n        }\n        else {\n            return new Position(newLineNumber, newColumn);\n        }\n    }\n    /**\n     * Derive a new position from this position.\n     *\n     * @param deltaLineNumber line number delta\n     * @param deltaColumn column delta\n     */\n    delta(deltaLineNumber = 0, deltaColumn = 0) {\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n    }\n    /**\n     * Test if this position equals other position\n     */\n    equals(other) {\n        return Position.equals(this, other);\n    }\n    /**\n     * Test if position `a` equals position `b`\n     */\n    static equals(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.lineNumber === b.lineNumber &&\n            a.column === b.column);\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be false.\n     */\n    isBefore(other) {\n        return Position.isBefore(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be false.\n     */\n    static isBefore(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column < b.column;\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be true.\n     */\n    isBeforeOrEqual(other) {\n        return Position.isBeforeOrEqual(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be true.\n     */\n    static isBeforeOrEqual(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column <= b.column;\n    }\n    /**\n     * A function that compares positions, useful for sorting\n     */\n    static compare(a, b) {\n        let aLineNumber = a.lineNumber | 0;\n        let bLineNumber = b.lineNumber | 0;\n        if (aLineNumber === bLineNumber) {\n            let aColumn = a.column | 0;\n            let bColumn = b.column | 0;\n            return aColumn - bColumn;\n        }\n        return aLineNumber - bLineNumber;\n    }\n    /**\n     * Clone this position.\n     */\n    clone() {\n        return new Position(this.lineNumber, this.column);\n    }\n    /**\n     * Convert to a human-readable representation.\n     */\n    toString() {\n        return '(' + this.lineNumber + ',' + this.column + ')';\n    }\n    // ---\n    /**\n     * Create a `Position` from an `IPosition`.\n     */\n    static lift(pos) {\n        return new Position(pos.lineNumber, pos.column);\n    }\n    /**\n     * Test if `obj` is an `IPosition`.\n     */\n    static isIPosition(obj) {\n        return (obj\n            && (typeof obj.lineNumber === 'number')\n            && (typeof obj.column === 'number'));\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nexport class Range {\n    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n            this.startLineNumber = endLineNumber;\n            this.startColumn = endColumn;\n            this.endLineNumber = startLineNumber;\n            this.endColumn = startColumn;\n        }\n        else {\n            this.startLineNumber = startLineNumber;\n            this.startColumn = startColumn;\n            this.endLineNumber = endLineNumber;\n            this.endColumn = endColumn;\n        }\n    }\n    /**\n     * Test if this range is empty.\n     */\n    isEmpty() {\n        return Range.isEmpty(this);\n    }\n    /**\n     * Test if `range` is empty.\n     */\n    static isEmpty(range) {\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n    }\n    /**\n     * Test if position is in this range. If the position is at the edges, will return true.\n     */\n    containsPosition(position) {\n        return Range.containsPosition(this, position);\n    }\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\n     */\n    static containsPosition(range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if range is in this range. If the range is equal to this range, will return true.\n     */\n    containsRange(range) {\n        return Range.containsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n     */\n    static containsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.\n     */\n    strictContainsRange(range) {\n        return Range.strictContainsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.\n     */\n    static strictContainsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    plusRange(range) {\n        return Range.plusRange(this, range);\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    static plusRange(a, b) {\n        let startLineNumber;\n        let startColumn;\n        let endLineNumber;\n        let endColumn;\n        if (b.startLineNumber < a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = b.startColumn;\n        }\n        else if (b.startLineNumber === a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = Math.min(b.startColumn, a.startColumn);\n        }\n        else {\n            startLineNumber = a.startLineNumber;\n            startColumn = a.startColumn;\n        }\n        if (b.endLineNumber > a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = b.endColumn;\n        }\n        else if (b.endLineNumber === a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = Math.max(b.endColumn, a.endColumn);\n        }\n        else {\n            endLineNumber = a.endLineNumber;\n            endColumn = a.endColumn;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    intersectRanges(range) {\n        return Range.intersectRanges(this, range);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    static intersectRanges(a, b) {\n        let resultStartLineNumber = a.startLineNumber;\n        let resultStartColumn = a.startColumn;\n        let resultEndLineNumber = a.endLineNumber;\n        let resultEndColumn = a.endColumn;\n        let otherStartLineNumber = b.startLineNumber;\n        let otherStartColumn = b.startColumn;\n        let otherEndLineNumber = b.endLineNumber;\n        let otherEndColumn = b.endColumn;\n        if (resultStartLineNumber < otherStartLineNumber) {\n            resultStartLineNumber = otherStartLineNumber;\n            resultStartColumn = otherStartColumn;\n        }\n        else if (resultStartLineNumber === otherStartLineNumber) {\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n        }\n        if (resultEndLineNumber > otherEndLineNumber) {\n            resultEndLineNumber = otherEndLineNumber;\n            resultEndColumn = otherEndColumn;\n        }\n        else if (resultEndLineNumber === otherEndLineNumber) {\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n        }\n        // Check if selection is now empty\n        if (resultStartLineNumber > resultEndLineNumber) {\n            return null;\n        }\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n            return null;\n        }\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n    }\n    /**\n     * Test if this range equals other.\n     */\n    equalsRange(other) {\n        return Range.equalsRange(this, other);\n    }\n    /**\n     * Test if range `a` equals `b`.\n     */\n    static equalsRange(a, b) {\n        return (!!a &&\n            !!b &&\n            a.startLineNumber === b.startLineNumber &&\n            a.startColumn === b.startColumn &&\n            a.endLineNumber === b.endLineNumber &&\n            a.endColumn === b.endColumn);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    getEndPosition() {\n        return Range.getEndPosition(this);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    static getEndPosition(range) {\n        return new Position(range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    getStartPosition() {\n        return Range.getStartPosition(this);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    static getStartPosition(range) {\n        return new Position(range.startLineNumber, range.startColumn);\n    }\n    /**\n     * Transform to a user presentable string representation.\n     */\n    toString() {\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n    }\n    /**\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    collapseToStart() {\n        return Range.collapseToStart(this);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    static collapseToStart(range) {\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n    }\n    // ---\n    static fromPositions(start, end = start) {\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    static lift(range) {\n        if (!range) {\n            return null;\n        }\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Test if `obj` is an `IRange`.\n     */\n    static isIRange(obj) {\n        return (obj\n            && (typeof obj.startLineNumber === 'number')\n            && (typeof obj.startColumn === 'number')\n            && (typeof obj.endLineNumber === 'number')\n            && (typeof obj.endColumn === 'number'));\n    }\n    /**\n     * Test if the two ranges are touching in any way.\n     */\n    static areIntersectingOrTouching(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n     */\n    static areIntersecting(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the startPosition and then on the endPosition\n     */\n    static compareRangesUsingStarts(a, b) {\n        if (a && b) {\n            const aStartLineNumber = a.startLineNumber | 0;\n            const bStartLineNumber = b.startLineNumber | 0;\n            if (aStartLineNumber === bStartLineNumber) {\n                const aStartColumn = a.startColumn | 0;\n                const bStartColumn = b.startColumn | 0;\n                if (aStartColumn === bStartColumn) {\n                    const aEndLineNumber = a.endLineNumber | 0;\n                    const bEndLineNumber = b.endLineNumber | 0;\n                    if (aEndLineNumber === bEndLineNumber) {\n                        const aEndColumn = a.endColumn | 0;\n                        const bEndColumn = b.endColumn | 0;\n                        return aEndColumn - bEndColumn;\n                    }\n                    return aEndLineNumber - bEndLineNumber;\n                }\n                return aStartColumn - bStartColumn;\n            }\n            return aStartLineNumber - bStartLineNumber;\n        }\n        const aExists = (a ? 1 : 0);\n        const bExists = (b ? 1 : 0);\n        return aExists - bExists;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the endPosition and then on the startPosition\n     */\n    static compareRangesUsingEnds(a, b) {\n        if (a.endLineNumber === b.endLineNumber) {\n            if (a.endColumn === b.endColumn) {\n                if (a.startLineNumber === b.startLineNumber) {\n                    return a.startColumn - b.startColumn;\n                }\n                return a.startLineNumber - b.startLineNumber;\n            }\n            return a.endColumn - b.endColumn;\n        }\n        return a.endLineNumber - b.endLineNumber;\n    }\n    /**\n     * Test if the range spans multiple lines.\n     */\n    static spansMultipleLines(range) {\n        return range.endLineNumber > range.startLineNumber;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LcsDiff } from '../../../base/common/diff/diff.js';\nimport * as strings from '../../../base/common/strings.js';\nconst MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n    const diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n    return diffAlgo.ComputeDiff(pretty);\n}\nclass LineSequence {\n    constructor(lines) {\n        const startColumns = [];\n        const endColumns = [];\n        for (let i = 0, length = lines.length; i < length; i++) {\n            startColumns[i] = getFirstNonBlankColumn(lines[i], 1);\n            endColumns[i] = getLastNonBlankColumn(lines[i], 1);\n        }\n        this.lines = lines;\n        this._startColumns = startColumns;\n        this._endColumns = endColumns;\n    }\n    getElements() {\n        const elements = [];\n        for (let i = 0, len = this.lines.length; i < len; i++) {\n            elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n        }\n        return elements;\n    }\n    getStrictElement(index) {\n        return this.lines[index];\n    }\n    getStartLineNumber(i) {\n        return i + 1;\n    }\n    getEndLineNumber(i) {\n        return i + 1;\n    }\n    createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n        const charCodes = [];\n        const lineNumbers = [];\n        const columns = [];\n        let len = 0;\n        for (let index = startIndex; index <= endIndex; index++) {\n            const lineContent = this.lines[index];\n            const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n            const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n            for (let col = startColumn; col < endColumn; col++) {\n                charCodes[len] = lineContent.charCodeAt(col - 1);\n                lineNumbers[len] = index + 1;\n                columns[len] = col;\n                len++;\n            }\n        }\n        return new CharSequence(charCodes, lineNumbers, columns);\n    }\n}\nclass CharSequence {\n    constructor(charCodes, lineNumbers, columns) {\n        this._charCodes = charCodes;\n        this._lineNumbers = lineNumbers;\n        this._columns = columns;\n    }\n    getElements() {\n        return this._charCodes;\n    }\n    getStartLineNumber(i) {\n        return this._lineNumbers[i];\n    }\n    getStartColumn(i) {\n        return this._columns[i];\n    }\n    getEndLineNumber(i) {\n        return this._lineNumbers[i];\n    }\n    getEndColumn(i) {\n        return this._columns[i] + 1;\n    }\n}\nclass CharChange {\n    constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalStartColumn = originalStartColumn;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.originalEndColumn = originalEndColumn;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedStartColumn = modifiedStartColumn;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.modifiedEndColumn = modifiedEndColumn;\n    }\n    static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {\n        let originalStartLineNumber;\n        let originalStartColumn;\n        let originalEndLineNumber;\n        let originalEndColumn;\n        let modifiedStartLineNumber;\n        let modifiedStartColumn;\n        let modifiedEndLineNumber;\n        let modifiedEndColumn;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = 0;\n            originalStartColumn = 0;\n            originalEndLineNumber = 0;\n            originalEndColumn = 0;\n        }\n        else {\n            originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n            originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n            originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n            originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = 0;\n            modifiedStartColumn = 0;\n            modifiedEndLineNumber = 0;\n            modifiedEndColumn = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n    }\n}\nfunction postProcessCharChanges(rawChanges) {\n    if (rawChanges.length <= 1) {\n        return rawChanges;\n    }\n    const result = [rawChanges[0]];\n    let prevChange = result[0];\n    for (let i = 1, len = rawChanges.length; i < len; i++) {\n        const currChange = rawChanges[i];\n        const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n        const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n        const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n            // Merge the current change into the previous one\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n        }\n        else {\n            // Add the current change\n            result.push(currChange);\n            prevChange = currChange;\n        }\n    }\n    return result;\n}\nclass LineChange {\n    constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.charChanges = charChanges;\n    }\n    static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n        let originalStartLineNumber;\n        let originalEndLineNumber;\n        let modifiedStartLineNumber;\n        let modifiedEndLineNumber;\n        let charChanges = undefined;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n            originalEndLineNumber = 0;\n        }\n        else {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n            modifiedEndLineNumber = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {\n            // Compute character changes for diff chunks of at most 20 lines...\n            const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n            const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;\n            if (shouldPostProcessCharChanges) {\n                rawChanges = postProcessCharChanges(rawChanges);\n            }\n            charChanges = [];\n            for (let i = 0, length = rawChanges.length; i < length; i++) {\n                charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n            }\n        }\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n    }\n}\nexport class DiffComputer {\n    constructor(originalLines, modifiedLines, opts) {\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n        this.originalLines = originalLines;\n        this.modifiedLines = modifiedLines;\n        this.original = new LineSequence(originalLines);\n        this.modified = new LineSequence(modifiedLines);\n        this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);\n        this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...\n    }\n    computeDiff() {\n        if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {\n            // empty original => fast path\n            if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n                return {\n                    quitEarly: false,\n                    changes: []\n                };\n            }\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: 1,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: this.modified.lines.length,\n                        charChanges: [{\n                                modifiedEndColumn: 0,\n                                modifiedEndLineNumber: 0,\n                                modifiedStartColumn: 0,\n                                modifiedStartLineNumber: 0,\n                                originalEndColumn: 0,\n                                originalEndLineNumber: 0,\n                                originalStartColumn: 0,\n                                originalStartLineNumber: 0\n                            }]\n                    }]\n            };\n        }\n        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n            // empty modified => fast path\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: this.original.lines.length,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: 1,\n                        charChanges: [{\n                                modifiedEndColumn: 0,\n                                modifiedEndLineNumber: 0,\n                                modifiedStartColumn: 0,\n                                modifiedStartLineNumber: 0,\n                                originalEndColumn: 0,\n                                originalEndLineNumber: 0,\n                                originalStartColumn: 0,\n                                originalStartLineNumber: 0\n                            }]\n                    }]\n            };\n        }\n        const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);\n        const rawChanges = diffResult.changes;\n        const quitEarly = diffResult.quitEarly;\n        // The diff is always computed with ignoring trim whitespace\n        // This ensures we get the prettiest diff\n        if (this.shouldIgnoreTrimWhitespace) {\n            const lineChanges = [];\n            for (let i = 0, length = rawChanges.length; i < length; i++) {\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n            }\n            return {\n                quitEarly: quitEarly,\n                changes: lineChanges\n            };\n        }\n        // Need to post-process and introduce changes where the trim whitespace is different\n        // Note that we are looping starting at -1 to also cover the lines before the first change\n        const result = [];\n        let originalLineIndex = 0;\n        let modifiedLineIndex = 0;\n        for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n            const nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n            const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n            const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n                const originalLine = this.originalLines[originalLineIndex];\n                const modifiedLine = this.modifiedLines[modifiedLineIndex];\n                if (originalLine !== modifiedLine) {\n                    // These lines differ only in trim whitespace\n                    // Check the leading whitespace\n                    {\n                        let originalStartColumn = getFirstNonBlankColumn(originalLine, 1);\n                        let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n                            const originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n                            const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalStartColumn--;\n                            modifiedStartColumn--;\n                        }\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n                        }\n                    }\n                    // Check the trailing whitespace\n                    {\n                        let originalEndColumn = getLastNonBlankColumn(originalLine, 1);\n                        let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);\n                        const originalMaxColumn = originalLine.length + 1;\n                        const modifiedMaxColumn = modifiedLine.length + 1;\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n                            const originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n                            const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalEndColumn++;\n                            modifiedEndColumn++;\n                        }\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n                        }\n                    }\n                }\n                originalLineIndex++;\n                modifiedLineIndex++;\n            }\n            if (nextChange) {\n                // Emit the actual change\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n                originalLineIndex += nextChange.originalLength;\n                modifiedLineIndex += nextChange.modifiedLength;\n            }\n        }\n        return {\n            quitEarly: quitEarly,\n            changes: result\n        };\n    }\n    _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n            // Merged into previous\n            return;\n        }\n        let charChanges = undefined;\n        if (this.shouldComputeCharChanges) {\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n        }\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n    }\n    _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        const len = result.length;\n        if (len === 0) {\n            return false;\n        }\n        const prevChange = result[len - 1];\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n            // Don't merge with inserts/deletes\n            return false;\n        }\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n            prevChange.originalEndLineNumber = originalLineNumber;\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\n            if (this.shouldComputeCharChanges && prevChange.charChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        return false;\n    }\n}\nfunction getFirstNonBlankColumn(txt, defaultValue) {\n    const r = strings.firstNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 1;\n}\nfunction getLastNonBlankColumn(txt, defaultValue) {\n    const r = strings.lastNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 2;\n}\nfunction createContinueProcessingPredicate(maximumRuntime) {\n    if (maximumRuntime === 0) {\n        return () => true;\n    }\n    const startTime = Date.now();\n    return () => {\n        return Date.now() - startTime < maximumRuntime;\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function toUint8(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 255 /* MAX_UINT_8 */) {\n        return 255 /* MAX_UINT_8 */;\n    }\n    return v | 0;\n}\nexport function toUint32(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 4294967295 /* MAX_UINT_32 */) {\n        return 4294967295 /* MAX_UINT_32 */;\n    }\n    return v | 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint32 } from '../../../base/common/uint.js';\nexport class PrefixSumIndexOfResult {\n    constructor(index, remainder) {\n        this._prefixSumIndexOfResultBrand = undefined;\n        this.index = index;\n        this.remainder = remainder;\n    }\n}\nexport class PrefixSumComputer {\n    constructor(values) {\n        this.values = values;\n        this.prefixSum = new Uint32Array(values.length);\n        this.prefixSumValidIndex = new Int32Array(1);\n        this.prefixSumValidIndex[0] = -1;\n    }\n    insertValues(insertIndex, insertValues) {\n        insertIndex = toUint32(insertIndex);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        const insertValuesLen = insertValues.length;\n        if (insertValuesLen === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n        this.values.set(insertValues, insertIndex);\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = insertIndex - 1;\n        }\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    changeValue(index, value) {\n        index = toUint32(index);\n        value = toUint32(value);\n        if (this.values[index] === value) {\n            return false;\n        }\n        this.values[index] = value;\n        if (index - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = index - 1;\n        }\n        return true;\n    }\n    removeValues(startIndex, count) {\n        startIndex = toUint32(startIndex);\n        count = toUint32(count);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        if (startIndex >= oldValues.length) {\n            return false;\n        }\n        let maxCount = oldValues.length - startIndex;\n        if (count >= maxCount) {\n            count = maxCount;\n        }\n        if (count === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length - count);\n        this.values.set(oldValues.subarray(0, startIndex), 0);\n        this.values.set(oldValues.subarray(startIndex + count), startIndex);\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = startIndex - 1;\n        }\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    getTotalSum() {\n        if (this.values.length === 0) {\n            return 0;\n        }\n        return this._getPrefixSum(this.values.length - 1);\n    }\n    getPrefixSum(index) {\n        if (index < 0) {\n            return 0;\n        }\n        index = toUint32(index);\n        return this._getPrefixSum(index);\n    }\n    _getPrefixSum(index) {\n        if (index <= this.prefixSumValidIndex[0]) {\n            return this.prefixSum[index];\n        }\n        let startIndex = this.prefixSumValidIndex[0] + 1;\n        if (startIndex === 0) {\n            this.prefixSum[0] = this.values[0];\n            startIndex++;\n        }\n        if (index >= this.values.length) {\n            index = this.values.length - 1;\n        }\n        for (let i = startIndex; i <= index; i++) {\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n        }\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n        return this.prefixSum[index];\n    }\n    getIndexOf(sum) {\n        sum = Math.floor(sum); //@perf\n        // Compute all sums (to get a fully valid prefixSum)\n        this.getTotalSum();\n        let low = 0;\n        let high = this.values.length - 1;\n        let mid = 0;\n        let midStop = 0;\n        let midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStop = this.prefixSum[mid];\n            midStart = midStop - this.values[mid];\n            if (sum < midStart) {\n                high = mid - 1;\n            }\n            else if (sum >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        return new PrefixSumIndexOfResult(mid, sum - midStart);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { splitLines } from '../../../base/common/strings.js';\nimport { Position } from '../core/position.js';\nimport { PrefixSumComputer } from '../viewModel/prefixSumComputer.js';\nexport class MirrorTextModel {\n    constructor(uri, lines, eol, versionId) {\n        this._uri = uri;\n        this._lines = lines;\n        this._eol = eol;\n        this._versionId = versionId;\n        this._lineStarts = null;\n        this._cachedTextValue = null;\n    }\n    dispose() {\n        this._lines.length = 0;\n    }\n    get version() {\n        return this._versionId;\n    }\n    getText() {\n        if (this._cachedTextValue === null) {\n            this._cachedTextValue = this._lines.join(this._eol);\n        }\n        return this._cachedTextValue;\n    }\n    onEvents(e) {\n        if (e.eol && e.eol !== this._eol) {\n            this._eol = e.eol;\n            this._lineStarts = null;\n        }\n        // Update my lines\n        const changes = e.changes;\n        for (const change of changes) {\n            this._acceptDeleteRange(change.range);\n            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n        }\n        this._versionId = e.versionId;\n        this._cachedTextValue = null;\n    }\n    _ensureLineStarts() {\n        if (!this._lineStarts) {\n            const eolLength = this._eol.length;\n            const linesLength = this._lines.length;\n            const lineStartValues = new Uint32Array(linesLength);\n            for (let i = 0; i < linesLength; i++) {\n                lineStartValues[i] = this._lines[i].length + eolLength;\n            }\n            this._lineStarts = new PrefixSumComputer(lineStartValues);\n        }\n    }\n    /**\n     * All changes to a line's text go through this method\n     */\n    _setLineText(lineIndex, newValue) {\n        this._lines[lineIndex] = newValue;\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n        }\n    }\n    _acceptDeleteRange(range) {\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            // Delete text on the affected line\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n            return;\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n        // Delete middle lines\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        }\n    }\n    _acceptInsertText(position, insertText) {\n        if (insertText.length === 0) {\n            // Nothing to insert\n            return;\n        }\n        let insertLines = splitLines(insertText);\n        if (insertLines.length === 1) {\n            // Inserting text on one line\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n                + insertLines[0]\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\n            return;\n        }\n        // Append overflowing text from first line to the end of text to insert\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n        // Delete overflowing text from first line and insert text on first line\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n            + insertLines[0]);\n        // Insert new lines & store lengths\n        let newLengths = new Uint32Array(insertLines.length - 1);\n        for (let i = 1; i < insertLines.length; i++) {\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\n        }\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords = '') {\n    let source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n    for (const sep of USUAL_WORD_SEPARATORS) {\n        if (allowInWords.indexOf(sep) >= 0) {\n            continue;\n        }\n        source += '\\\\' + sep;\n    }\n    source += '\\\\s]+)';\n    return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport const DEFAULT_WORD_REGEXP = createWordRegExp();\nexport function ensureValidWordDefinition(wordDefinition) {\n    let result = DEFAULT_WORD_REGEXP;\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\n        if (!wordDefinition.global) {\n            let flags = 'g';\n            if (wordDefinition.ignoreCase) {\n                flags += 'i';\n            }\n            if (wordDefinition.multiline) {\n                flags += 'm';\n            }\n            if (wordDefinition.unicode) {\n                flags += 'u';\n            }\n            result = new RegExp(wordDefinition.source, flags);\n        }\n        else {\n            result = wordDefinition;\n        }\n    }\n    result.lastIndex = 0;\n    return result;\n}\nconst _defaultConfig = {\n    maxLen: 1000,\n    windowSize: 15,\n    timeBudget: 150\n};\nexport function getWordAtText(column, wordDefinition, text, textOffset, config = _defaultConfig) {\n    if (text.length > config.maxLen) {\n        // don't throw strings that long at the regexp\n        // but use a sub-string in which a word must occur\n        let start = column - config.maxLen / 2;\n        if (start < 0) {\n            start = 0;\n        }\n        else {\n            textOffset += start;\n        }\n        text = text.substring(start, column + config.maxLen / 2);\n        return getWordAtText(column, wordDefinition, text, textOffset, config);\n    }\n    const t1 = Date.now();\n    const pos = column - 1 - textOffset;\n    let prevRegexIndex = -1;\n    let match = null;\n    for (let i = 1;; i++) {\n        // check time budget\n        if (Date.now() - t1 >= config.timeBudget) {\n            break;\n        }\n        // reset the index at which the regexp should start matching, also know where it\n        // should stop so that subsequent search don't repeat previous searches\n        const regexIndex = pos - config.windowSize * i;\n        wordDefinition.lastIndex = Math.max(0, regexIndex);\n        const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);\n        if (!thisMatch && match) {\n            // stop: we have something\n            break;\n        }\n        match = thisMatch;\n        // stop: searched at start\n        if (regexIndex <= 0) {\n            break;\n        }\n        prevRegexIndex = regexIndex;\n    }\n    if (match) {\n        let result = {\n            word: match[0],\n            startColumn: textOffset + 1 + match.index,\n            endColumn: textOffset + 1 + match.index + match[0].length\n        };\n        wordDefinition.lastIndex = 0;\n        return result;\n    }\n    return null;\n}\nfunction _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {\n    let match;\n    while (match = wordDefinition.exec(text)) {\n        const matchIndex = match.index || 0;\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n            return match;\n        }\n        else if (stopPos > 0 && matchIndex > stopPos) {\n            return null;\n        }\n    }\n    return null;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint8 } from '../../../base/common/uint.js';\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nexport class CharacterClassifier {\n    constructor(_defaultValue) {\n        let defaultValue = toUint8(_defaultValue);\n        this._defaultValue = defaultValue;\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n        this._map = new Map();\n    }\n    static _createAsciiMap(defaultValue) {\n        let asciiMap = new Uint8Array(256);\n        for (let i = 0; i < 256; i++) {\n            asciiMap[i] = defaultValue;\n        }\n        return asciiMap;\n    }\n    set(charCode, _value) {\n        let value = toUint8(_value);\n        if (charCode >= 0 && charCode < 256) {\n            this._asciiMap[charCode] = value;\n        }\n        else {\n            this._map.set(charCode, value);\n        }\n    }\n    get(charCode) {\n        if (charCode >= 0 && charCode < 256) {\n            return this._asciiMap[charCode];\n        }\n        else {\n            return (this._map.get(charCode) || this._defaultValue);\n        }\n    }\n}\nexport class CharacterSet {\n    constructor() {\n        this._actual = new CharacterClassifier(0 /* False */);\n    }\n    add(charCode) {\n        this._actual.set(charCode, 1 /* True */);\n    }\n    has(charCode) {\n        return (this._actual.get(charCode) === 1 /* True */);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nexport class Uint8Matrix {\n    constructor(rows, cols, defaultValue) {\n        const data = new Uint8Array(rows * cols);\n        for (let i = 0, len = rows * cols; i < len; i++) {\n            data[i] = defaultValue;\n        }\n        this._data = data;\n        this.rows = rows;\n        this.cols = cols;\n    }\n    get(row, col) {\n        return this._data[row * this.cols + col];\n    }\n    set(row, col, value) {\n        this._data[row * this.cols + col] = value;\n    }\n}\nexport class StateMachine {\n    constructor(edges) {\n        let maxCharCode = 0;\n        let maxState = 0 /* Invalid */;\n        for (let i = 0, len = edges.length; i < len; i++) {\n            let [from, chCode, to] = edges[i];\n            if (chCode > maxCharCode) {\n                maxCharCode = chCode;\n            }\n            if (from > maxState) {\n                maxState = from;\n            }\n            if (to > maxState) {\n                maxState = to;\n            }\n        }\n        maxCharCode++;\n        maxState++;\n        let states = new Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);\n        for (let i = 0, len = edges.length; i < len; i++) {\n            let [from, chCode, to] = edges[i];\n            states.set(from, chCode, to);\n        }\n        this._states = states;\n        this._maxCharCode = maxCharCode;\n    }\n    nextState(currentState, chCode) {\n        if (chCode < 0 || chCode >= this._maxCharCode) {\n            return 0 /* Invalid */;\n        }\n        return this._states.get(currentState, chCode);\n    }\n}\n// State machine for http:// or https:// or file://\nlet _stateMachine = null;\nfunction getStateMachine() {\n    if (_stateMachine === null) {\n        _stateMachine = new StateMachine([\n            [1 /* Start */, 104 /* h */, 2 /* H */],\n            [1 /* Start */, 72 /* H */, 2 /* H */],\n            [1 /* Start */, 102 /* f */, 6 /* F */],\n            [1 /* Start */, 70 /* F */, 6 /* F */],\n            [2 /* H */, 116 /* t */, 3 /* HT */],\n            [2 /* H */, 84 /* T */, 3 /* HT */],\n            [3 /* HT */, 116 /* t */, 4 /* HTT */],\n            [3 /* HT */, 84 /* T */, 4 /* HTT */],\n            [4 /* HTT */, 112 /* p */, 5 /* HTTP */],\n            [4 /* HTT */, 80 /* P */, 5 /* HTTP */],\n            [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],\n            [6 /* F */, 105 /* i */, 7 /* FI */],\n            [6 /* F */, 73 /* I */, 7 /* FI */],\n            [7 /* FI */, 108 /* l */, 8 /* FIL */],\n            [7 /* FI */, 76 /* L */, 8 /* FIL */],\n            [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],\n            [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],\n            [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],\n            [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],\n            [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],\n        ]);\n    }\n    return _stateMachine;\n}\nlet _classifier = null;\nfunction getClassifier() {\n    if (_classifier === null) {\n        _classifier = new CharacterClassifier(0 /* None */);\n        const FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';\n        for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);\n        }\n        const CANNOT_END_WITH_CHARACTERS = '.,;';\n        for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);\n        }\n    }\n    return _classifier;\n}\nexport class LinkComputer {\n    static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n        // Do not allow to end link in certain characters...\n        let lastIncludedCharIndex = linkEndIndex - 1;\n        do {\n            const chCode = line.charCodeAt(lastIncludedCharIndex);\n            const chClass = classifier.get(chCode);\n            if (chClass !== 2 /* CannotEndIn */) {\n                break;\n            }\n            lastIncludedCharIndex--;\n        } while (lastIncludedCharIndex > linkBeginIndex);\n        // Handle links enclosed in parens, square brackets and curlys.\n        if (linkBeginIndex > 0) {\n            const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n            const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n            if ((charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */)\n                || (charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */)\n                || (charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */)) {\n                // Do not end in ) if ( is before the link start\n                // Do not end in ] if [ is before the link start\n                // Do not end in } if { is before the link start\n                lastIncludedCharIndex--;\n            }\n        }\n        return {\n            range: {\n                startLineNumber: lineNumber,\n                startColumn: linkBeginIndex + 1,\n                endLineNumber: lineNumber,\n                endColumn: lastIncludedCharIndex + 2\n            },\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n        };\n    }\n    static computeLinks(model, stateMachine = getStateMachine()) {\n        const classifier = getClassifier();\n        let result = [];\n        for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n            const line = model.getLineContent(i);\n            const len = line.length;\n            let j = 0;\n            let linkBeginIndex = 0;\n            let linkBeginChCode = 0;\n            let state = 1 /* Start */;\n            let hasOpenParens = false;\n            let hasOpenSquareBracket = false;\n            let inSquareBrackets = false;\n            let hasOpenCurlyBracket = false;\n            while (j < len) {\n                let resetStateMachine = false;\n                const chCode = line.charCodeAt(j);\n                if (state === 13 /* Accept */) {\n                    let chClass;\n                    switch (chCode) {\n                        case 40 /* OpenParen */:\n                            hasOpenParens = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 41 /* CloseParen */:\n                            chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 91 /* OpenSquareBracket */:\n                            inSquareBrackets = true;\n                            hasOpenSquareBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 93 /* CloseSquareBracket */:\n                            inSquareBrackets = false;\n                            chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 123 /* OpenCurlyBrace */:\n                            hasOpenCurlyBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 125 /* CloseCurlyBrace */:\n                            chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        /* The following three rules make it that ' or \" or ` are allowed inside links if the link began with a different one */\n                        case 39 /* SingleQuote */:\n                            chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 34 /* DoubleQuote */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 96 /* BackTick */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 42 /* Asterisk */:\n                            // `*` terminates a link if the link began with `*`\n                            chClass = (linkBeginChCode === 42 /* Asterisk */) ? 1 /* ForceTermination */ : 0 /* None */;\n                            break;\n                        case 124 /* Pipe */:\n                            // `|` terminates a link if the link began with `|`\n                            chClass = (linkBeginChCode === 124 /* Pipe */) ? 1 /* ForceTermination */ : 0 /* None */;\n                            break;\n                        case 32 /* Space */:\n                            // ` ` allow space in between [ and ]\n                            chClass = (inSquareBrackets ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        default:\n                            chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n                        resetStateMachine = true;\n                    }\n                }\n                else if (state === 12 /* End */) {\n                    let chClass;\n                    if (chCode === 91 /* OpenSquareBracket */) {\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n                        hasOpenSquareBracket = true;\n                        chClass = 0 /* None */;\n                    }\n                    else {\n                        chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        resetStateMachine = true;\n                    }\n                    else {\n                        state = 13 /* Accept */;\n                    }\n                }\n                else {\n                    state = stateMachine.nextState(state, chCode);\n                    if (state === 0 /* Invalid */) {\n                        resetStateMachine = true;\n                    }\n                }\n                if (resetStateMachine) {\n                    state = 1 /* Start */;\n                    hasOpenParens = false;\n                    hasOpenSquareBracket = false;\n                    hasOpenCurlyBracket = false;\n                    // Record where the link started\n                    linkBeginIndex = j + 1;\n                    linkBeginChCode = chCode;\n                }\n                j++;\n            }\n            if (state === 13 /* Accept */) {\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n            }\n        }\n        return result;\n    }\n}\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nexport function computeLinks(model) {\n    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n        // Unknown caller!\n        return [];\n    }\n    return LinkComputer.computeLinks(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class BasicInplaceReplace {\n    constructor() {\n        this._defaultValueSet = [\n            ['true', 'false'],\n            ['True', 'False'],\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n            ['public', 'protected', 'private'],\n        ];\n    }\n    navigateValueSet(range1, text1, range2, text2, up) {\n        if (range1 && text1) {\n            let result = this.doNavigateValueSet(text1, up);\n            if (result) {\n                return {\n                    range: range1,\n                    value: result\n                };\n            }\n        }\n        if (range2 && text2) {\n            let result = this.doNavigateValueSet(text2, up);\n            if (result) {\n                return {\n                    range: range2,\n                    value: result\n                };\n            }\n        }\n        return null;\n    }\n    doNavigateValueSet(text, up) {\n        let numberResult = this.numberReplace(text, up);\n        if (numberResult !== null) {\n            return numberResult;\n        }\n        return this.textReplace(text, up);\n    }\n    numberReplace(value, up) {\n        let precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n        let n1 = Number(value);\n        let n2 = parseFloat(value);\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n            if (n1 === 0 && !up) {\n                return null; // don't do negative\n                //\t\t\t} else if(n1 === 9 && up) {\n                //\t\t\t\treturn null; // don't insert 10 into a number\n            }\n            else {\n                n1 = Math.floor(n1 * precision);\n                n1 += up ? precision : -precision;\n                return String(n1 / precision);\n            }\n        }\n        return null;\n    }\n    textReplace(value, up) {\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\n    }\n    valueSetsReplace(valueSets, value, up) {\n        let result = null;\n        for (let i = 0, len = valueSets.length; result === null && i < len; i++) {\n            result = this.valueSetReplace(valueSets[i], value, up);\n        }\n        return result;\n    }\n    valueSetReplace(valueSet, value, up) {\n        let idx = valueSet.indexOf(value);\n        if (idx >= 0) {\n            idx += up ? +1 : -1;\n            if (idx < 0) {\n                idx = valueSet.length - 1;\n            }\n            else {\n                idx %= valueSet.length;\n            }\n            return valueSet[idx];\n        }\n        return null;\n    }\n}\nBasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter, Event } from './event.js';\nconst shortcutEvent = Object.freeze(function (callback, context) {\n    const handle = setTimeout(callback.bind(context), 0);\n    return { dispose() { clearTimeout(handle); } };\n});\nexport var CancellationToken;\n(function (CancellationToken) {\n    function isCancellationToken(thing) {\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n            return true;\n        }\n        if (thing instanceof MutableToken) {\n            return true;\n        }\n        if (!thing || typeof thing !== 'object') {\n            return false;\n        }\n        return typeof thing.isCancellationRequested === 'boolean'\n            && typeof thing.onCancellationRequested === 'function';\n    }\n    CancellationToken.isCancellationToken = isCancellationToken;\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: Event.None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: shortcutEvent\n    });\n})(CancellationToken || (CancellationToken = {}));\nclass MutableToken {\n    constructor() {\n        this._isCancelled = false;\n        this._emitter = null;\n    }\n    cancel() {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    }\n    get isCancellationRequested() {\n        return this._isCancelled;\n    }\n    get onCancellationRequested() {\n        if (this._isCancelled) {\n            return shortcutEvent;\n        }\n        if (!this._emitter) {\n            this._emitter = new Emitter();\n        }\n        return this._emitter.event;\n    }\n    dispose() {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = null;\n        }\n    }\n}\nexport class CancellationTokenSource {\n    constructor(parent) {\n        this._token = undefined;\n        this._parentListener = undefined;\n        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\n    }\n    get token() {\n        if (!this._token) {\n            // be lazy and create the token only when\n            // actually needed\n            this._token = new MutableToken();\n        }\n        return this._token;\n    }\n    cancel() {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually cancel\n            this._token.cancel();\n        }\n    }\n    dispose(cancel = false) {\n        if (cancel) {\n            this.cancel();\n        }\n        if (this._parentListener) {\n            this._parentListener.dispose();\n        }\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass KeyCodeStrMap {\n    constructor() {\n        this._keyCodeToStr = [];\n        this._strToKeyCode = Object.create(null);\n    }\n    define(keyCode, str) {\n        this._keyCodeToStr[keyCode] = str;\n        this._strToKeyCode[str.toLowerCase()] = keyCode;\n    }\n    keyCodeToStr(keyCode) {\n        return this._keyCodeToStr[keyCode];\n    }\n    strToKeyCode(str) {\n        return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;\n    }\n}\nconst uiMap = new KeyCodeStrMap();\nconst userSettingsUSMap = new KeyCodeStrMap();\nconst userSettingsGeneralMap = new KeyCodeStrMap();\nexport const EVENT_KEY_CODE_MAP = new Array(230);\nexport const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {};\nconst scanCodeIntToStr = [];\nconst scanCodeStrToInt = Object.create(null);\nconst scanCodeLowerCaseStrToInt = Object.create(null);\n/**\n * -1 if a ScanCode => KeyCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_CODE_TO_KEY_CODE = [];\n/**\n * -1 if a KeyCode => ScanCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_KEY_CODE_TO_CODE = [];\nfor (let i = 0; i <= 193 /* MAX_VALUE */; i++) {\n    IMMUTABLE_CODE_TO_KEY_CODE[i] = -1 /* DependsOnKbLayout */;\n}\nfor (let i = 0; i <= 126 /* MAX_VALUE */; i++) {\n    IMMUTABLE_KEY_CODE_TO_CODE[i] = -1 /* DependsOnKbLayout */;\n}\n(function () {\n    // See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n    // See https://github.com/microsoft/node-native-keymap/blob/master/deps/chromium/keyboard_codes_win.h\n    const empty = '';\n    const mappings = [\n        // keyCodeOrd, immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel\n        [0, 1, 0 /* None */, 'None', 0 /* Unknown */, 'unknown', 0, 'VK_UNKNOWN', empty, empty],\n        [0, 1, 1 /* Hyper */, 'Hyper', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 2 /* Super */, 'Super', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 3 /* Fn */, 'Fn', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 4 /* FnLock */, 'FnLock', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 5 /* Suspend */, 'Suspend', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 6 /* Resume */, 'Resume', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 7 /* Turbo */, 'Turbo', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 8 /* Sleep */, 'Sleep', 0 /* Unknown */, empty, 0, 'VK_SLEEP', empty, empty],\n        [0, 1, 9 /* WakeUp */, 'WakeUp', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [31, 0, 10 /* KeyA */, 'KeyA', 31 /* KeyA */, 'A', 65, 'VK_A', empty, empty],\n        [32, 0, 11 /* KeyB */, 'KeyB', 32 /* KeyB */, 'B', 66, 'VK_B', empty, empty],\n        [33, 0, 12 /* KeyC */, 'KeyC', 33 /* KeyC */, 'C', 67, 'VK_C', empty, empty],\n        [34, 0, 13 /* KeyD */, 'KeyD', 34 /* KeyD */, 'D', 68, 'VK_D', empty, empty],\n        [35, 0, 14 /* KeyE */, 'KeyE', 35 /* KeyE */, 'E', 69, 'VK_E', empty, empty],\n        [36, 0, 15 /* KeyF */, 'KeyF', 36 /* KeyF */, 'F', 70, 'VK_F', empty, empty],\n        [37, 0, 16 /* KeyG */, 'KeyG', 37 /* KeyG */, 'G', 71, 'VK_G', empty, empty],\n        [38, 0, 17 /* KeyH */, 'KeyH', 38 /* KeyH */, 'H', 72, 'VK_H', empty, empty],\n        [39, 0, 18 /* KeyI */, 'KeyI', 39 /* KeyI */, 'I', 73, 'VK_I', empty, empty],\n        [40, 0, 19 /* KeyJ */, 'KeyJ', 40 /* KeyJ */, 'J', 74, 'VK_J', empty, empty],\n        [41, 0, 20 /* KeyK */, 'KeyK', 41 /* KeyK */, 'K', 75, 'VK_K', empty, empty],\n        [42, 0, 21 /* KeyL */, 'KeyL', 42 /* KeyL */, 'L', 76, 'VK_L', empty, empty],\n        [43, 0, 22 /* KeyM */, 'KeyM', 43 /* KeyM */, 'M', 77, 'VK_M', empty, empty],\n        [44, 0, 23 /* KeyN */, 'KeyN', 44 /* KeyN */, 'N', 78, 'VK_N', empty, empty],\n        [45, 0, 24 /* KeyO */, 'KeyO', 45 /* KeyO */, 'O', 79, 'VK_O', empty, empty],\n        [46, 0, 25 /* KeyP */, 'KeyP', 46 /* KeyP */, 'P', 80, 'VK_P', empty, empty],\n        [47, 0, 26 /* KeyQ */, 'KeyQ', 47 /* KeyQ */, 'Q', 81, 'VK_Q', empty, empty],\n        [48, 0, 27 /* KeyR */, 'KeyR', 48 /* KeyR */, 'R', 82, 'VK_R', empty, empty],\n        [49, 0, 28 /* KeyS */, 'KeyS', 49 /* KeyS */, 'S', 83, 'VK_S', empty, empty],\n        [50, 0, 29 /* KeyT */, 'KeyT', 50 /* KeyT */, 'T', 84, 'VK_T', empty, empty],\n        [51, 0, 30 /* KeyU */, 'KeyU', 51 /* KeyU */, 'U', 85, 'VK_U', empty, empty],\n        [52, 0, 31 /* KeyV */, 'KeyV', 52 /* KeyV */, 'V', 86, 'VK_V', empty, empty],\n        [53, 0, 32 /* KeyW */, 'KeyW', 53 /* KeyW */, 'W', 87, 'VK_W', empty, empty],\n        [54, 0, 33 /* KeyX */, 'KeyX', 54 /* KeyX */, 'X', 88, 'VK_X', empty, empty],\n        [55, 0, 34 /* KeyY */, 'KeyY', 55 /* KeyY */, 'Y', 89, 'VK_Y', empty, empty],\n        [56, 0, 35 /* KeyZ */, 'KeyZ', 56 /* KeyZ */, 'Z', 90, 'VK_Z', empty, empty],\n        [22, 0, 36 /* Digit1 */, 'Digit1', 22 /* Digit1 */, '1', 49, 'VK_1', empty, empty],\n        [23, 0, 37 /* Digit2 */, 'Digit2', 23 /* Digit2 */, '2', 50, 'VK_2', empty, empty],\n        [24, 0, 38 /* Digit3 */, 'Digit3', 24 /* Digit3 */, '3', 51, 'VK_3', empty, empty],\n        [25, 0, 39 /* Digit4 */, 'Digit4', 25 /* Digit4 */, '4', 52, 'VK_4', empty, empty],\n        [26, 0, 40 /* Digit5 */, 'Digit5', 26 /* Digit5 */, '5', 53, 'VK_5', empty, empty],\n        [27, 0, 41 /* Digit6 */, 'Digit6', 27 /* Digit6 */, '6', 54, 'VK_6', empty, empty],\n        [28, 0, 42 /* Digit7 */, 'Digit7', 28 /* Digit7 */, '7', 55, 'VK_7', empty, empty],\n        [29, 0, 43 /* Digit8 */, 'Digit8', 29 /* Digit8 */, '8', 56, 'VK_8', empty, empty],\n        [30, 0, 44 /* Digit9 */, 'Digit9', 30 /* Digit9 */, '9', 57, 'VK_9', empty, empty],\n        [21, 0, 45 /* Digit0 */, 'Digit0', 21 /* Digit0 */, '0', 48, 'VK_0', empty, empty],\n        [3, 1, 46 /* Enter */, 'Enter', 3 /* Enter */, 'Enter', 13, 'VK_RETURN', empty, empty],\n        [9, 1, 47 /* Escape */, 'Escape', 9 /* Escape */, 'Escape', 27, 'VK_ESCAPE', empty, empty],\n        [1, 1, 48 /* Backspace */, 'Backspace', 1 /* Backspace */, 'Backspace', 8, 'VK_BACK', empty, empty],\n        [2, 1, 49 /* Tab */, 'Tab', 2 /* Tab */, 'Tab', 9, 'VK_TAB', empty, empty],\n        [10, 1, 50 /* Space */, 'Space', 10 /* Space */, 'Space', 32, 'VK_SPACE', empty, empty],\n        [83, 0, 51 /* Minus */, 'Minus', 83 /* Minus */, '-', 189, 'VK_OEM_MINUS', '-', 'OEM_MINUS'],\n        [81, 0, 52 /* Equal */, 'Equal', 81 /* Equal */, '=', 187, 'VK_OEM_PLUS', '=', 'OEM_PLUS'],\n        [87, 0, 53 /* BracketLeft */, 'BracketLeft', 87 /* BracketLeft */, '[', 219, 'VK_OEM_4', '[', 'OEM_4'],\n        [89, 0, 54 /* BracketRight */, 'BracketRight', 89 /* BracketRight */, ']', 221, 'VK_OEM_6', ']', 'OEM_6'],\n        [88, 0, 55 /* Backslash */, 'Backslash', 88 /* Backslash */, '\\\\', 220, 'VK_OEM_5', '\\\\', 'OEM_5'],\n        [0, 0, 56 /* IntlHash */, 'IntlHash', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [80, 0, 57 /* Semicolon */, 'Semicolon', 80 /* Semicolon */, ';', 186, 'VK_OEM_1', ';', 'OEM_1'],\n        [90, 0, 58 /* Quote */, 'Quote', 90 /* Quote */, '\\'', 222, 'VK_OEM_7', '\\'', 'OEM_7'],\n        [86, 0, 59 /* Backquote */, 'Backquote', 86 /* Backquote */, '`', 192, 'VK_OEM_3', '`', 'OEM_3'],\n        [82, 0, 60 /* Comma */, 'Comma', 82 /* Comma */, ',', 188, 'VK_OEM_COMMA', ',', 'OEM_COMMA'],\n        [84, 0, 61 /* Period */, 'Period', 84 /* Period */, '.', 190, 'VK_OEM_PERIOD', '.', 'OEM_PERIOD'],\n        [85, 0, 62 /* Slash */, 'Slash', 85 /* Slash */, '/', 191, 'VK_OEM_2', '/', 'OEM_2'],\n        [8, 1, 63 /* CapsLock */, 'CapsLock', 8 /* CapsLock */, 'CapsLock', 20, 'VK_CAPITAL', empty, empty],\n        [59, 1, 64 /* F1 */, 'F1', 59 /* F1 */, 'F1', 112, 'VK_F1', empty, empty],\n        [60, 1, 65 /* F2 */, 'F2', 60 /* F2 */, 'F2', 113, 'VK_F2', empty, empty],\n        [61, 1, 66 /* F3 */, 'F3', 61 /* F3 */, 'F3', 114, 'VK_F3', empty, empty],\n        [62, 1, 67 /* F4 */, 'F4', 62 /* F4 */, 'F4', 115, 'VK_F4', empty, empty],\n        [63, 1, 68 /* F5 */, 'F5', 63 /* F5 */, 'F5', 116, 'VK_F5', empty, empty],\n        [64, 1, 69 /* F6 */, 'F6', 64 /* F6 */, 'F6', 117, 'VK_F6', empty, empty],\n        [65, 1, 70 /* F7 */, 'F7', 65 /* F7 */, 'F7', 118, 'VK_F7', empty, empty],\n        [66, 1, 71 /* F8 */, 'F8', 66 /* F8 */, 'F8', 119, 'VK_F8', empty, empty],\n        [67, 1, 72 /* F9 */, 'F9', 67 /* F9 */, 'F9', 120, 'VK_F9', empty, empty],\n        [68, 1, 73 /* F10 */, 'F10', 68 /* F10 */, 'F10', 121, 'VK_F10', empty, empty],\n        [69, 1, 74 /* F11 */, 'F11', 69 /* F11 */, 'F11', 122, 'VK_F11', empty, empty],\n        [70, 1, 75 /* F12 */, 'F12', 70 /* F12 */, 'F12', 123, 'VK_F12', empty, empty],\n        [0, 1, 76 /* PrintScreen */, 'PrintScreen', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [79, 1, 77 /* ScrollLock */, 'ScrollLock', 79 /* ScrollLock */, 'ScrollLock', 145, 'VK_SCROLL', empty, empty],\n        [7, 1, 78 /* Pause */, 'Pause', 7 /* PauseBreak */, 'PauseBreak', 19, 'VK_PAUSE', empty, empty],\n        [19, 1, 79 /* Insert */, 'Insert', 19 /* Insert */, 'Insert', 45, 'VK_INSERT', empty, empty],\n        [14, 1, 80 /* Home */, 'Home', 14 /* Home */, 'Home', 36, 'VK_HOME', empty, empty],\n        [11, 1, 81 /* PageUp */, 'PageUp', 11 /* PageUp */, 'PageUp', 33, 'VK_PRIOR', empty, empty],\n        [20, 1, 82 /* Delete */, 'Delete', 20 /* Delete */, 'Delete', 46, 'VK_DELETE', empty, empty],\n        [13, 1, 83 /* End */, 'End', 13 /* End */, 'End', 35, 'VK_END', empty, empty],\n        [12, 1, 84 /* PageDown */, 'PageDown', 12 /* PageDown */, 'PageDown', 34, 'VK_NEXT', empty, empty],\n        [17, 1, 85 /* ArrowRight */, 'ArrowRight', 17 /* RightArrow */, 'RightArrow', 39, 'VK_RIGHT', 'Right', empty],\n        [15, 1, 86 /* ArrowLeft */, 'ArrowLeft', 15 /* LeftArrow */, 'LeftArrow', 37, 'VK_LEFT', 'Left', empty],\n        [18, 1, 87 /* ArrowDown */, 'ArrowDown', 18 /* DownArrow */, 'DownArrow', 40, 'VK_DOWN', 'Down', empty],\n        [16, 1, 88 /* ArrowUp */, 'ArrowUp', 16 /* UpArrow */, 'UpArrow', 38, 'VK_UP', 'Up', empty],\n        [78, 1, 89 /* NumLock */, 'NumLock', 78 /* NumLock */, 'NumLock', 144, 'VK_NUMLOCK', empty, empty],\n        [108, 1, 90 /* NumpadDivide */, 'NumpadDivide', 108 /* NumpadDivide */, 'NumPad_Divide', 111, 'VK_DIVIDE', empty, empty],\n        [103, 1, 91 /* NumpadMultiply */, 'NumpadMultiply', 103 /* NumpadMultiply */, 'NumPad_Multiply', 106, 'VK_MULTIPLY', empty, empty],\n        [106, 1, 92 /* NumpadSubtract */, 'NumpadSubtract', 106 /* NumpadSubtract */, 'NumPad_Subtract', 109, 'VK_SUBTRACT', empty, empty],\n        [104, 1, 93 /* NumpadAdd */, 'NumpadAdd', 104 /* NumpadAdd */, 'NumPad_Add', 107, 'VK_ADD', empty, empty],\n        [3, 1, 94 /* NumpadEnter */, 'NumpadEnter', 3 /* Enter */, empty, 0, empty, empty, empty],\n        [94, 1, 95 /* Numpad1 */, 'Numpad1', 94 /* Numpad1 */, 'NumPad1', 97, 'VK_NUMPAD1', empty, empty],\n        [95, 1, 96 /* Numpad2 */, 'Numpad2', 95 /* Numpad2 */, 'NumPad2', 98, 'VK_NUMPAD2', empty, empty],\n        [96, 1, 97 /* Numpad3 */, 'Numpad3', 96 /* Numpad3 */, 'NumPad3', 99, 'VK_NUMPAD3', empty, empty],\n        [97, 1, 98 /* Numpad4 */, 'Numpad4', 97 /* Numpad4 */, 'NumPad4', 100, 'VK_NUMPAD4', empty, empty],\n        [98, 1, 99 /* Numpad5 */, 'Numpad5', 98 /* Numpad5 */, 'NumPad5', 101, 'VK_NUMPAD5', empty, empty],\n        [99, 1, 100 /* Numpad6 */, 'Numpad6', 99 /* Numpad6 */, 'NumPad6', 102, 'VK_NUMPAD6', empty, empty],\n        [100, 1, 101 /* Numpad7 */, 'Numpad7', 100 /* Numpad7 */, 'NumPad7', 103, 'VK_NUMPAD7', empty, empty],\n        [101, 1, 102 /* Numpad8 */, 'Numpad8', 101 /* Numpad8 */, 'NumPad8', 104, 'VK_NUMPAD8', empty, empty],\n        [102, 1, 103 /* Numpad9 */, 'Numpad9', 102 /* Numpad9 */, 'NumPad9', 105, 'VK_NUMPAD9', empty, empty],\n        [93, 1, 104 /* Numpad0 */, 'Numpad0', 93 /* Numpad0 */, 'NumPad0', 96, 'VK_NUMPAD0', empty, empty],\n        [107, 1, 105 /* NumpadDecimal */, 'NumpadDecimal', 107 /* NumpadDecimal */, 'NumPad_Decimal', 110, 'VK_DECIMAL', empty, empty],\n        [92, 0, 106 /* IntlBackslash */, 'IntlBackslash', 92 /* IntlBackslash */, 'OEM_102', 226, 'VK_OEM_102', empty, empty],\n        [58, 1, 107 /* ContextMenu */, 'ContextMenu', 58 /* ContextMenu */, 'ContextMenu', 93, empty, empty, empty],\n        [0, 1, 108 /* Power */, 'Power', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 109 /* NumpadEqual */, 'NumpadEqual', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [71, 1, 110 /* F13 */, 'F13', 71 /* F13 */, 'F13', 124, 'VK_F13', empty, empty],\n        [72, 1, 111 /* F14 */, 'F14', 72 /* F14 */, 'F14', 125, 'VK_F14', empty, empty],\n        [73, 1, 112 /* F15 */, 'F15', 73 /* F15 */, 'F15', 126, 'VK_F15', empty, empty],\n        [74, 1, 113 /* F16 */, 'F16', 74 /* F16 */, 'F16', 127, 'VK_F16', empty, empty],\n        [75, 1, 114 /* F17 */, 'F17', 75 /* F17 */, 'F17', 128, 'VK_F17', empty, empty],\n        [76, 1, 115 /* F18 */, 'F18', 76 /* F18 */, 'F18', 129, 'VK_F18', empty, empty],\n        [77, 1, 116 /* F19 */, 'F19', 77 /* F19 */, 'F19', 130, 'VK_F19', empty, empty],\n        [0, 1, 117 /* F20 */, 'F20', 0 /* Unknown */, empty, 0, 'VK_F20', empty, empty],\n        [0, 1, 118 /* F21 */, 'F21', 0 /* Unknown */, empty, 0, 'VK_F21', empty, empty],\n        [0, 1, 119 /* F22 */, 'F22', 0 /* Unknown */, empty, 0, 'VK_F22', empty, empty],\n        [0, 1, 120 /* F23 */, 'F23', 0 /* Unknown */, empty, 0, 'VK_F23', empty, empty],\n        [0, 1, 121 /* F24 */, 'F24', 0 /* Unknown */, empty, 0, 'VK_F24', empty, empty],\n        [0, 1, 122 /* Open */, 'Open', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 123 /* Help */, 'Help', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 124 /* Select */, 'Select', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 125 /* Again */, 'Again', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 126 /* Undo */, 'Undo', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 127 /* Cut */, 'Cut', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 128 /* Copy */, 'Copy', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 129 /* Paste */, 'Paste', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 130 /* Find */, 'Find', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 131 /* AudioVolumeMute */, 'AudioVolumeMute', 112 /* AudioVolumeMute */, 'AudioVolumeMute', 173, 'VK_VOLUME_MUTE', empty, empty],\n        [0, 1, 132 /* AudioVolumeUp */, 'AudioVolumeUp', 113 /* AudioVolumeUp */, 'AudioVolumeUp', 175, 'VK_VOLUME_UP', empty, empty],\n        [0, 1, 133 /* AudioVolumeDown */, 'AudioVolumeDown', 114 /* AudioVolumeDown */, 'AudioVolumeDown', 174, 'VK_VOLUME_DOWN', empty, empty],\n        [105, 1, 134 /* NumpadComma */, 'NumpadComma', 105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator', 108, 'VK_SEPARATOR', empty, empty],\n        [110, 0, 135 /* IntlRo */, 'IntlRo', 110 /* ABNT_C1 */, 'ABNT_C1', 193, 'VK_ABNT_C1', empty, empty],\n        [0, 1, 136 /* KanaMode */, 'KanaMode', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 0, 137 /* IntlYen */, 'IntlYen', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 138 /* Convert */, 'Convert', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 139 /* NonConvert */, 'NonConvert', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 140 /* Lang1 */, 'Lang1', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 141 /* Lang2 */, 'Lang2', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 142 /* Lang3 */, 'Lang3', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 143 /* Lang4 */, 'Lang4', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 144 /* Lang5 */, 'Lang5', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 145 /* Abort */, 'Abort', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 146 /* Props */, 'Props', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 147 /* NumpadParenLeft */, 'NumpadParenLeft', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 148 /* NumpadParenRight */, 'NumpadParenRight', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 149 /* NumpadBackspace */, 'NumpadBackspace', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 150 /* NumpadMemoryStore */, 'NumpadMemoryStore', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 151 /* NumpadMemoryRecall */, 'NumpadMemoryRecall', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 152 /* NumpadMemoryClear */, 'NumpadMemoryClear', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 153 /* NumpadMemoryAdd */, 'NumpadMemoryAdd', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 154 /* NumpadMemorySubtract */, 'NumpadMemorySubtract', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 155 /* NumpadClear */, 'NumpadClear', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 156 /* NumpadClearEntry */, 'NumpadClearEntry', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [5, 1, 0 /* None */, empty, 5 /* Ctrl */, 'Ctrl', 17, 'VK_CONTROL', empty, empty],\n        [4, 1, 0 /* None */, empty, 4 /* Shift */, 'Shift', 16, 'VK_SHIFT', empty, empty],\n        [6, 1, 0 /* None */, empty, 6 /* Alt */, 'Alt', 18, 'VK_MENU', empty, empty],\n        [57, 1, 0 /* None */, empty, 57 /* Meta */, 'Meta', 0, 'VK_COMMAND', empty, empty],\n        [5, 1, 157 /* ControlLeft */, 'ControlLeft', 5 /* Ctrl */, empty, 0, 'VK_LCONTROL', empty, empty],\n        [4, 1, 158 /* ShiftLeft */, 'ShiftLeft', 4 /* Shift */, empty, 0, 'VK_LSHIFT', empty, empty],\n        [6, 1, 159 /* AltLeft */, 'AltLeft', 6 /* Alt */, empty, 0, 'VK_LMENU', empty, empty],\n        [57, 1, 160 /* MetaLeft */, 'MetaLeft', 57 /* Meta */, empty, 0, 'VK_LWIN', empty, empty],\n        [5, 1, 161 /* ControlRight */, 'ControlRight', 5 /* Ctrl */, empty, 0, 'VK_RCONTROL', empty, empty],\n        [4, 1, 162 /* ShiftRight */, 'ShiftRight', 4 /* Shift */, empty, 0, 'VK_RSHIFT', empty, empty],\n        [6, 1, 163 /* AltRight */, 'AltRight', 6 /* Alt */, empty, 0, 'VK_RMENU', empty, empty],\n        [57, 1, 164 /* MetaRight */, 'MetaRight', 57 /* Meta */, empty, 0, 'VK_RWIN', empty, empty],\n        [0, 1, 165 /* BrightnessUp */, 'BrightnessUp', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 166 /* BrightnessDown */, 'BrightnessDown', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 167 /* MediaPlay */, 'MediaPlay', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 168 /* MediaRecord */, 'MediaRecord', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 169 /* MediaFastForward */, 'MediaFastForward', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 170 /* MediaRewind */, 'MediaRewind', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [114, 1, 171 /* MediaTrackNext */, 'MediaTrackNext', 119 /* MediaTrackNext */, 'MediaTrackNext', 176, 'VK_MEDIA_NEXT_TRACK', empty, empty],\n        [115, 1, 172 /* MediaTrackPrevious */, 'MediaTrackPrevious', 120 /* MediaTrackPrevious */, 'MediaTrackPrevious', 177, 'VK_MEDIA_PREV_TRACK', empty, empty],\n        [116, 1, 173 /* MediaStop */, 'MediaStop', 121 /* MediaStop */, 'MediaStop', 178, 'VK_MEDIA_STOP', empty, empty],\n        [0, 1, 174 /* Eject */, 'Eject', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [117, 1, 175 /* MediaPlayPause */, 'MediaPlayPause', 122 /* MediaPlayPause */, 'MediaPlayPause', 179, 'VK_MEDIA_PLAY_PAUSE', empty, empty],\n        [0, 1, 176 /* MediaSelect */, 'MediaSelect', 123 /* LaunchMediaPlayer */, 'LaunchMediaPlayer', 181, 'VK_MEDIA_LAUNCH_MEDIA_SELECT', empty, empty],\n        [0, 1, 177 /* LaunchMail */, 'LaunchMail', 124 /* LaunchMail */, 'LaunchMail', 180, 'VK_MEDIA_LAUNCH_MAIL', empty, empty],\n        [0, 1, 178 /* LaunchApp2 */, 'LaunchApp2', 125 /* LaunchApp2 */, 'LaunchApp2', 183, 'VK_MEDIA_LAUNCH_APP2', empty, empty],\n        [0, 1, 179 /* LaunchApp1 */, 'LaunchApp1', 0 /* Unknown */, empty, 0, 'VK_MEDIA_LAUNCH_APP1', empty, empty],\n        [0, 1, 180 /* SelectTask */, 'SelectTask', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 181 /* LaunchScreenSaver */, 'LaunchScreenSaver', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 182 /* BrowserSearch */, 'BrowserSearch', 115 /* BrowserSearch */, 'BrowserSearch', 170, 'VK_BROWSER_SEARCH', empty, empty],\n        [0, 1, 183 /* BrowserHome */, 'BrowserHome', 116 /* BrowserHome */, 'BrowserHome', 172, 'VK_BROWSER_HOME', empty, empty],\n        [112, 1, 184 /* BrowserBack */, 'BrowserBack', 117 /* BrowserBack */, 'BrowserBack', 166, 'VK_BROWSER_BACK', empty, empty],\n        [113, 1, 185 /* BrowserForward */, 'BrowserForward', 118 /* BrowserForward */, 'BrowserForward', 167, 'VK_BROWSER_FORWARD', empty, empty],\n        [0, 1, 186 /* BrowserStop */, 'BrowserStop', 0 /* Unknown */, empty, 0, 'VK_BROWSER_STOP', empty, empty],\n        [0, 1, 187 /* BrowserRefresh */, 'BrowserRefresh', 0 /* Unknown */, empty, 0, 'VK_BROWSER_REFRESH', empty, empty],\n        [0, 1, 188 /* BrowserFavorites */, 'BrowserFavorites', 0 /* Unknown */, empty, 0, 'VK_BROWSER_FAVORITES', empty, empty],\n        [0, 1, 189 /* ZoomToggle */, 'ZoomToggle', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 190 /* MailReply */, 'MailReply', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 191 /* MailForward */, 'MailForward', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 192 /* MailSend */, 'MailSend', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        // See https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html\n        // If an Input Method Editor is processing key input and the event is keydown, return 229.\n        [109, 1, 0 /* None */, empty, 109 /* KEY_IN_COMPOSITION */, 'KeyInComposition', 229, empty, empty, empty],\n        [111, 1, 0 /* None */, empty, 111 /* ABNT_C2 */, 'ABNT_C2', 194, 'VK_ABNT_C2', empty, empty],\n        [91, 1, 0 /* None */, empty, 91 /* OEM_8 */, 'OEM_8', 223, 'VK_OEM_8', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CLEAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANGUL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_JUNJA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_FINAL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANJA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANJI', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CONVERT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONCONVERT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ACCEPT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_MODECHANGE', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SELECT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PRINT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXECUTE', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SNAPSHOT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HELP', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_APPS', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PROCESSKEY', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PACKET', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_SBCSCHAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_DBCSCHAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ATTN', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CRSEL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXSEL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EREOF', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PLAY', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ZOOM', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONAME', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PA1', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_OEM_CLEAR', empty, empty],\n    ];\n    let seenKeyCode = [];\n    let seenScanCode = [];\n    for (const mapping of mappings) {\n        const [_keyCodeOrd, immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel] = mapping;\n        if (!seenScanCode[scanCode]) {\n            seenScanCode[scanCode] = true;\n            scanCodeIntToStr[scanCode] = scanCodeStr;\n            scanCodeStrToInt[scanCodeStr] = scanCode;\n            scanCodeLowerCaseStrToInt[scanCodeStr.toLowerCase()] = scanCode;\n            if (immutable) {\n                IMMUTABLE_CODE_TO_KEY_CODE[scanCode] = keyCode;\n                if ((keyCode !== 0 /* Unknown */)\n                    && (keyCode !== 3 /* Enter */)\n                    && (keyCode !== 5 /* Ctrl */)\n                    && (keyCode !== 4 /* Shift */)\n                    && (keyCode !== 6 /* Alt */)\n                    && (keyCode !== 57 /* Meta */)) {\n                    IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = scanCode;\n                }\n            }\n        }\n        if (!seenKeyCode[keyCode]) {\n            seenKeyCode[keyCode] = true;\n            if (!keyCodeStr) {\n                throw new Error(`String representation missing for key code ${keyCode} around scan code ${scanCodeStr}`);\n            }\n            uiMap.define(keyCode, keyCodeStr);\n            userSettingsUSMap.define(keyCode, usUserSettingsLabel || keyCodeStr);\n            userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel || usUserSettingsLabel || keyCodeStr);\n        }\n        if (eventKeyCode) {\n            EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;\n        }\n        if (vkey) {\n            NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;\n        }\n    }\n    // Manually added due to the exclusion above (due to duplication with NumpadEnter)\n    IMMUTABLE_KEY_CODE_TO_CODE[3 /* Enter */] = 46 /* Enter */;\n})();\nexport var KeyCodeUtils;\n(function (KeyCodeUtils) {\n    function toString(keyCode) {\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toString = toString;\n    function fromString(key) {\n        return uiMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromString = fromString;\n    function toUserSettingsUS(keyCode) {\n        return userSettingsUSMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\n    function toUserSettingsGeneral(keyCode) {\n        return userSettingsGeneralMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\n    function fromUserSettings(key) {\n        return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromUserSettings = fromUserSettings;\n    function toElectronAccelerator(keyCode) {\n        if (keyCode >= 93 /* Numpad0 */ && keyCode <= 108 /* NumpadDivide */) {\n            // [Electron Accelerators] Electron is able to parse numpad keys, but unfortunately it\n            // renders them just as regular keys in menus. For example, num0 is rendered as \"0\",\n            // numdiv is rendered as \"/\", numsub is rendered as \"-\".\n            //\n            // This can lead to incredible confusion, as it makes numpad based keybindings indistinguishable\n            // from keybindings based on regular keys.\n            //\n            // We therefore need to fall back to custom rendering for numpad keys.\n            return null;\n        }\n        switch (keyCode) {\n            case 16 /* UpArrow */:\n                return 'Up';\n            case 18 /* DownArrow */:\n                return 'Down';\n            case 15 /* LeftArrow */:\n                return 'Left';\n            case 17 /* RightArrow */:\n                return 'Right';\n        }\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toElectronAccelerator = toElectronAccelerator;\n})(KeyCodeUtils || (KeyCodeUtils = {}));\nexport function KeyChord(firstPart, secondPart) {\n    const chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\n    return (firstPart | chordPart) >>> 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\nexport var AccessibilitySupport;\n(function (AccessibilitySupport) {\n    /**\n     * This should be the browser case where it is not known if a screen reader is attached or no.\n     */\n    AccessibilitySupport[AccessibilitySupport[\"Unknown\"] = 0] = \"Unknown\";\n    AccessibilitySupport[AccessibilitySupport[\"Disabled\"] = 1] = \"Disabled\";\n    AccessibilitySupport[AccessibilitySupport[\"Enabled\"] = 2] = \"Enabled\";\n})(AccessibilitySupport || (AccessibilitySupport = {}));\nexport var CompletionItemInsertTextRule;\n(function (CompletionItemInsertTextRule) {\n    /**\n     * Adjust whitespace/indentation of multiline insert texts to\n     * match the current line indentation.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\n    /**\n     * `insertText` is a snippet.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind[CompletionItemKind[\"Method\"] = 0] = \"Method\";\n    CompletionItemKind[CompletionItemKind[\"Function\"] = 1] = \"Function\";\n    CompletionItemKind[CompletionItemKind[\"Constructor\"] = 2] = \"Constructor\";\n    CompletionItemKind[CompletionItemKind[\"Field\"] = 3] = \"Field\";\n    CompletionItemKind[CompletionItemKind[\"Variable\"] = 4] = \"Variable\";\n    CompletionItemKind[CompletionItemKind[\"Class\"] = 5] = \"Class\";\n    CompletionItemKind[CompletionItemKind[\"Struct\"] = 6] = \"Struct\";\n    CompletionItemKind[CompletionItemKind[\"Interface\"] = 7] = \"Interface\";\n    CompletionItemKind[CompletionItemKind[\"Module\"] = 8] = \"Module\";\n    CompletionItemKind[CompletionItemKind[\"Property\"] = 9] = \"Property\";\n    CompletionItemKind[CompletionItemKind[\"Event\"] = 10] = \"Event\";\n    CompletionItemKind[CompletionItemKind[\"Operator\"] = 11] = \"Operator\";\n    CompletionItemKind[CompletionItemKind[\"Unit\"] = 12] = \"Unit\";\n    CompletionItemKind[CompletionItemKind[\"Value\"] = 13] = \"Value\";\n    CompletionItemKind[CompletionItemKind[\"Constant\"] = 14] = \"Constant\";\n    CompletionItemKind[CompletionItemKind[\"Enum\"] = 15] = \"Enum\";\n    CompletionItemKind[CompletionItemKind[\"EnumMember\"] = 16] = \"EnumMember\";\n    CompletionItemKind[CompletionItemKind[\"Keyword\"] = 17] = \"Keyword\";\n    CompletionItemKind[CompletionItemKind[\"Text\"] = 18] = \"Text\";\n    CompletionItemKind[CompletionItemKind[\"Color\"] = 19] = \"Color\";\n    CompletionItemKind[CompletionItemKind[\"File\"] = 20] = \"File\";\n    CompletionItemKind[CompletionItemKind[\"Reference\"] = 21] = \"Reference\";\n    CompletionItemKind[CompletionItemKind[\"Customcolor\"] = 22] = \"Customcolor\";\n    CompletionItemKind[CompletionItemKind[\"Folder\"] = 23] = \"Folder\";\n    CompletionItemKind[CompletionItemKind[\"TypeParameter\"] = 24] = \"TypeParameter\";\n    CompletionItemKind[CompletionItemKind[\"User\"] = 25] = \"User\";\n    CompletionItemKind[CompletionItemKind[\"Issue\"] = 26] = \"Issue\";\n    CompletionItemKind[CompletionItemKind[\"Snippet\"] = 27] = \"Snippet\";\n})(CompletionItemKind || (CompletionItemKind = {}));\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n    CompletionItemTag[CompletionItemTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * How a suggest provider was triggered.\n */\nexport var CompletionTriggerKind;\n(function (CompletionTriggerKind) {\n    CompletionTriggerKind[CompletionTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerCharacter\"] = 1] = \"TriggerCharacter\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerForIncompleteCompletions\"] = 2] = \"TriggerForIncompleteCompletions\";\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\n/**\n * A positioning preference for rendering content widgets.\n */\nexport var ContentWidgetPositionPreference;\n(function (ContentWidgetPositionPreference) {\n    /**\n     * Place the content widget exactly at a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"EXACT\"] = 0] = \"EXACT\";\n    /**\n     * Place the content widget above a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"ABOVE\"] = 1] = \"ABOVE\";\n    /**\n     * Place the content widget below a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"BELOW\"] = 2] = \"BELOW\";\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\n/**\n * Describes the reason the cursor has changed its position.\n */\nexport var CursorChangeReason;\n(function (CursorChangeReason) {\n    /**\n     * Unknown or not set.\n     */\n    CursorChangeReason[CursorChangeReason[\"NotSet\"] = 0] = \"NotSet\";\n    /**\n     * A `model.setValue()` was called.\n     */\n    CursorChangeReason[CursorChangeReason[\"ContentFlush\"] = 1] = \"ContentFlush\";\n    /**\n     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\n     */\n    CursorChangeReason[CursorChangeReason[\"RecoverFromMarkers\"] = 2] = \"RecoverFromMarkers\";\n    /**\n     * There was an explicit user gesture.\n     */\n    CursorChangeReason[CursorChangeReason[\"Explicit\"] = 3] = \"Explicit\";\n    /**\n     * There was a Paste.\n     */\n    CursorChangeReason[CursorChangeReason[\"Paste\"] = 4] = \"Paste\";\n    /**\n     * There was an Undo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Undo\"] = 5] = \"Undo\";\n    /**\n     * There was a Redo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Redo\"] = 6] = \"Redo\";\n})(CursorChangeReason || (CursorChangeReason = {}));\n/**\n * The default end of line to use when instantiating models.\n */\nexport var DefaultEndOfLine;\n(function (DefaultEndOfLine) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"CRLF\"] = 2] = \"CRLF\";\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * Configuration options for auto indentation in the editor\n */\nexport var EditorAutoIndentStrategy;\n(function (EditorAutoIndentStrategy) {\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"None\"] = 0] = \"None\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Keep\"] = 1] = \"Keep\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Brackets\"] = 2] = \"Brackets\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Advanced\"] = 3] = \"Advanced\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Full\"] = 4] = \"Full\";\n})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {}));\nexport var EditorOption;\n(function (EditorOption) {\n    EditorOption[EditorOption[\"acceptSuggestionOnCommitCharacter\"] = 0] = \"acceptSuggestionOnCommitCharacter\";\n    EditorOption[EditorOption[\"acceptSuggestionOnEnter\"] = 1] = \"acceptSuggestionOnEnter\";\n    EditorOption[EditorOption[\"accessibilitySupport\"] = 2] = \"accessibilitySupport\";\n    EditorOption[EditorOption[\"accessibilityPageSize\"] = 3] = \"accessibilityPageSize\";\n    EditorOption[EditorOption[\"ariaLabel\"] = 4] = \"ariaLabel\";\n    EditorOption[EditorOption[\"autoClosingBrackets\"] = 5] = \"autoClosingBrackets\";\n    EditorOption[EditorOption[\"autoClosingDelete\"] = 6] = \"autoClosingDelete\";\n    EditorOption[EditorOption[\"autoClosingOvertype\"] = 7] = \"autoClosingOvertype\";\n    EditorOption[EditorOption[\"autoClosingQuotes\"] = 8] = \"autoClosingQuotes\";\n    EditorOption[EditorOption[\"autoIndent\"] = 9] = \"autoIndent\";\n    EditorOption[EditorOption[\"automaticLayout\"] = 10] = \"automaticLayout\";\n    EditorOption[EditorOption[\"autoSurround\"] = 11] = \"autoSurround\";\n    EditorOption[EditorOption[\"bracketPairColorization\"] = 12] = \"bracketPairColorization\";\n    EditorOption[EditorOption[\"guides\"] = 13] = \"guides\";\n    EditorOption[EditorOption[\"codeLens\"] = 14] = \"codeLens\";\n    EditorOption[EditorOption[\"codeLensFontFamily\"] = 15] = \"codeLensFontFamily\";\n    EditorOption[EditorOption[\"codeLensFontSize\"] = 16] = \"codeLensFontSize\";\n    EditorOption[EditorOption[\"colorDecorators\"] = 17] = \"colorDecorators\";\n    EditorOption[EditorOption[\"columnSelection\"] = 18] = \"columnSelection\";\n    EditorOption[EditorOption[\"comments\"] = 19] = \"comments\";\n    EditorOption[EditorOption[\"contextmenu\"] = 20] = \"contextmenu\";\n    EditorOption[EditorOption[\"copyWithSyntaxHighlighting\"] = 21] = \"copyWithSyntaxHighlighting\";\n    EditorOption[EditorOption[\"cursorBlinking\"] = 22] = \"cursorBlinking\";\n    EditorOption[EditorOption[\"cursorSmoothCaretAnimation\"] = 23] = \"cursorSmoothCaretAnimation\";\n    EditorOption[EditorOption[\"cursorStyle\"] = 24] = \"cursorStyle\";\n    EditorOption[EditorOption[\"cursorSurroundingLines\"] = 25] = \"cursorSurroundingLines\";\n    EditorOption[EditorOption[\"cursorSurroundingLinesStyle\"] = 26] = \"cursorSurroundingLinesStyle\";\n    EditorOption[EditorOption[\"cursorWidth\"] = 27] = \"cursorWidth\";\n    EditorOption[EditorOption[\"disableLayerHinting\"] = 28] = \"disableLayerHinting\";\n    EditorOption[EditorOption[\"disableMonospaceOptimizations\"] = 29] = \"disableMonospaceOptimizations\";\n    EditorOption[EditorOption[\"domReadOnly\"] = 30] = \"domReadOnly\";\n    EditorOption[EditorOption[\"dragAndDrop\"] = 31] = \"dragAndDrop\";\n    EditorOption[EditorOption[\"emptySelectionClipboard\"] = 32] = \"emptySelectionClipboard\";\n    EditorOption[EditorOption[\"extraEditorClassName\"] = 33] = \"extraEditorClassName\";\n    EditorOption[EditorOption[\"fastScrollSensitivity\"] = 34] = \"fastScrollSensitivity\";\n    EditorOption[EditorOption[\"find\"] = 35] = \"find\";\n    EditorOption[EditorOption[\"fixedOverflowWidgets\"] = 36] = \"fixedOverflowWidgets\";\n    EditorOption[EditorOption[\"folding\"] = 37] = \"folding\";\n    EditorOption[EditorOption[\"foldingStrategy\"] = 38] = \"foldingStrategy\";\n    EditorOption[EditorOption[\"foldingHighlight\"] = 39] = \"foldingHighlight\";\n    EditorOption[EditorOption[\"foldingImportsByDefault\"] = 40] = \"foldingImportsByDefault\";\n    EditorOption[EditorOption[\"unfoldOnClickAfterEndOfLine\"] = 41] = \"unfoldOnClickAfterEndOfLine\";\n    EditorOption[EditorOption[\"fontFamily\"] = 42] = \"fontFamily\";\n    EditorOption[EditorOption[\"fontInfo\"] = 43] = \"fontInfo\";\n    EditorOption[EditorOption[\"fontLigatures\"] = 44] = \"fontLigatures\";\n    EditorOption[EditorOption[\"fontSize\"] = 45] = \"fontSize\";\n    EditorOption[EditorOption[\"fontWeight\"] = 46] = \"fontWeight\";\n    EditorOption[EditorOption[\"formatOnPaste\"] = 47] = \"formatOnPaste\";\n    EditorOption[EditorOption[\"formatOnType\"] = 48] = \"formatOnType\";\n    EditorOption[EditorOption[\"glyphMargin\"] = 49] = \"glyphMargin\";\n    EditorOption[EditorOption[\"gotoLocation\"] = 50] = \"gotoLocation\";\n    EditorOption[EditorOption[\"hideCursorInOverviewRuler\"] = 51] = \"hideCursorInOverviewRuler\";\n    EditorOption[EditorOption[\"hover\"] = 52] = \"hover\";\n    EditorOption[EditorOption[\"inDiffEditor\"] = 53] = \"inDiffEditor\";\n    EditorOption[EditorOption[\"inlineSuggest\"] = 54] = \"inlineSuggest\";\n    EditorOption[EditorOption[\"letterSpacing\"] = 55] = \"letterSpacing\";\n    EditorOption[EditorOption[\"lightbulb\"] = 56] = \"lightbulb\";\n    EditorOption[EditorOption[\"lineDecorationsWidth\"] = 57] = \"lineDecorationsWidth\";\n    EditorOption[EditorOption[\"lineHeight\"] = 58] = \"lineHeight\";\n    EditorOption[EditorOption[\"lineNumbers\"] = 59] = \"lineNumbers\";\n    EditorOption[EditorOption[\"lineNumbersMinChars\"] = 60] = \"lineNumbersMinChars\";\n    EditorOption[EditorOption[\"linkedEditing\"] = 61] = \"linkedEditing\";\n    EditorOption[EditorOption[\"links\"] = 62] = \"links\";\n    EditorOption[EditorOption[\"matchBrackets\"] = 63] = \"matchBrackets\";\n    EditorOption[EditorOption[\"minimap\"] = 64] = \"minimap\";\n    EditorOption[EditorOption[\"mouseStyle\"] = 65] = \"mouseStyle\";\n    EditorOption[EditorOption[\"mouseWheelScrollSensitivity\"] = 66] = \"mouseWheelScrollSensitivity\";\n    EditorOption[EditorOption[\"mouseWheelZoom\"] = 67] = \"mouseWheelZoom\";\n    EditorOption[EditorOption[\"multiCursorMergeOverlapping\"] = 68] = \"multiCursorMergeOverlapping\";\n    EditorOption[EditorOption[\"multiCursorModifier\"] = 69] = \"multiCursorModifier\";\n    EditorOption[EditorOption[\"multiCursorPaste\"] = 70] = \"multiCursorPaste\";\n    EditorOption[EditorOption[\"occurrencesHighlight\"] = 71] = \"occurrencesHighlight\";\n    EditorOption[EditorOption[\"overviewRulerBorder\"] = 72] = \"overviewRulerBorder\";\n    EditorOption[EditorOption[\"overviewRulerLanes\"] = 73] = \"overviewRulerLanes\";\n    EditorOption[EditorOption[\"padding\"] = 74] = \"padding\";\n    EditorOption[EditorOption[\"parameterHints\"] = 75] = \"parameterHints\";\n    EditorOption[EditorOption[\"peekWidgetDefaultFocus\"] = 76] = \"peekWidgetDefaultFocus\";\n    EditorOption[EditorOption[\"definitionLinkOpensInPeek\"] = 77] = \"definitionLinkOpensInPeek\";\n    EditorOption[EditorOption[\"quickSuggestions\"] = 78] = \"quickSuggestions\";\n    EditorOption[EditorOption[\"quickSuggestionsDelay\"] = 79] = \"quickSuggestionsDelay\";\n    EditorOption[EditorOption[\"readOnly\"] = 80] = \"readOnly\";\n    EditorOption[EditorOption[\"renameOnType\"] = 81] = \"renameOnType\";\n    EditorOption[EditorOption[\"renderControlCharacters\"] = 82] = \"renderControlCharacters\";\n    EditorOption[EditorOption[\"renderFinalNewline\"] = 83] = \"renderFinalNewline\";\n    EditorOption[EditorOption[\"renderLineHighlight\"] = 84] = \"renderLineHighlight\";\n    EditorOption[EditorOption[\"renderLineHighlightOnlyWhenFocus\"] = 85] = \"renderLineHighlightOnlyWhenFocus\";\n    EditorOption[EditorOption[\"renderValidationDecorations\"] = 86] = \"renderValidationDecorations\";\n    EditorOption[EditorOption[\"renderWhitespace\"] = 87] = \"renderWhitespace\";\n    EditorOption[EditorOption[\"revealHorizontalRightPadding\"] = 88] = \"revealHorizontalRightPadding\";\n    EditorOption[EditorOption[\"roundedSelection\"] = 89] = \"roundedSelection\";\n    EditorOption[EditorOption[\"rulers\"] = 90] = \"rulers\";\n    EditorOption[EditorOption[\"scrollbar\"] = 91] = \"scrollbar\";\n    EditorOption[EditorOption[\"scrollBeyondLastColumn\"] = 92] = \"scrollBeyondLastColumn\";\n    EditorOption[EditorOption[\"scrollBeyondLastLine\"] = 93] = \"scrollBeyondLastLine\";\n    EditorOption[EditorOption[\"scrollPredominantAxis\"] = 94] = \"scrollPredominantAxis\";\n    EditorOption[EditorOption[\"selectionClipboard\"] = 95] = \"selectionClipboard\";\n    EditorOption[EditorOption[\"selectionHighlight\"] = 96] = \"selectionHighlight\";\n    EditorOption[EditorOption[\"selectOnLineNumbers\"] = 97] = \"selectOnLineNumbers\";\n    EditorOption[EditorOption[\"showFoldingControls\"] = 98] = \"showFoldingControls\";\n    EditorOption[EditorOption[\"showUnused\"] = 99] = \"showUnused\";\n    EditorOption[EditorOption[\"snippetSuggestions\"] = 100] = \"snippetSuggestions\";\n    EditorOption[EditorOption[\"smartSelect\"] = 101] = \"smartSelect\";\n    EditorOption[EditorOption[\"smoothScrolling\"] = 102] = \"smoothScrolling\";\n    EditorOption[EditorOption[\"stickyTabStops\"] = 103] = \"stickyTabStops\";\n    EditorOption[EditorOption[\"stopRenderingLineAfter\"] = 104] = \"stopRenderingLineAfter\";\n    EditorOption[EditorOption[\"suggest\"] = 105] = \"suggest\";\n    EditorOption[EditorOption[\"suggestFontSize\"] = 106] = \"suggestFontSize\";\n    EditorOption[EditorOption[\"suggestLineHeight\"] = 107] = \"suggestLineHeight\";\n    EditorOption[EditorOption[\"suggestOnTriggerCharacters\"] = 108] = \"suggestOnTriggerCharacters\";\n    EditorOption[EditorOption[\"suggestSelection\"] = 109] = \"suggestSelection\";\n    EditorOption[EditorOption[\"tabCompletion\"] = 110] = \"tabCompletion\";\n    EditorOption[EditorOption[\"tabIndex\"] = 111] = \"tabIndex\";\n    EditorOption[EditorOption[\"unusualLineTerminators\"] = 112] = \"unusualLineTerminators\";\n    EditorOption[EditorOption[\"useShadowDOM\"] = 113] = \"useShadowDOM\";\n    EditorOption[EditorOption[\"useTabStops\"] = 114] = \"useTabStops\";\n    EditorOption[EditorOption[\"wordSeparators\"] = 115] = \"wordSeparators\";\n    EditorOption[EditorOption[\"wordWrap\"] = 116] = \"wordWrap\";\n    EditorOption[EditorOption[\"wordWrapBreakAfterCharacters\"] = 117] = \"wordWrapBreakAfterCharacters\";\n    EditorOption[EditorOption[\"wordWrapBreakBeforeCharacters\"] = 118] = \"wordWrapBreakBeforeCharacters\";\n    EditorOption[EditorOption[\"wordWrapColumn\"] = 119] = \"wordWrapColumn\";\n    EditorOption[EditorOption[\"wordWrapOverride1\"] = 120] = \"wordWrapOverride1\";\n    EditorOption[EditorOption[\"wordWrapOverride2\"] = 121] = \"wordWrapOverride2\";\n    EditorOption[EditorOption[\"wrappingIndent\"] = 122] = \"wrappingIndent\";\n    EditorOption[EditorOption[\"wrappingStrategy\"] = 123] = \"wrappingStrategy\";\n    EditorOption[EditorOption[\"showDeprecated\"] = 124] = \"showDeprecated\";\n    EditorOption[EditorOption[\"inlayHints\"] = 125] = \"inlayHints\";\n    EditorOption[EditorOption[\"editorClassName\"] = 126] = \"editorClassName\";\n    EditorOption[EditorOption[\"pixelRatio\"] = 127] = \"pixelRatio\";\n    EditorOption[EditorOption[\"tabFocusMode\"] = 128] = \"tabFocusMode\";\n    EditorOption[EditorOption[\"layoutInfo\"] = 129] = \"layoutInfo\";\n    EditorOption[EditorOption[\"wrappingInfo\"] = 130] = \"wrappingInfo\";\n})(EditorOption || (EditorOption = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLinePreference;\n(function (EndOfLinePreference) {\n    /**\n     * Use the end of line character identified in the text buffer.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"TextDefined\"] = 0] = \"TextDefined\";\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"CRLF\"] = 2] = \"CRLF\";\n})(EndOfLinePreference || (EndOfLinePreference = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLineSequence;\n(function (EndOfLineSequence) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"LF\"] = 0] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"CRLF\"] = 1] = \"CRLF\";\n})(EndOfLineSequence || (EndOfLineSequence = {}));\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nexport var IndentAction;\n(function (IndentAction) {\n    /**\n     * Insert new line and copy the previous line's indentation.\n     */\n    IndentAction[IndentAction[\"None\"] = 0] = \"None\";\n    /**\n     * Insert new line and indent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\n    /**\n     * Insert two new lines:\n     *  - the first one indented which will hold the cursor\n     *  - the second one at the same indentation level\n     */\n    IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\n    /**\n     * Insert new line and outdent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\n})(IndentAction || (IndentAction = {}));\nexport var InlayHintKind;\n(function (InlayHintKind) {\n    InlayHintKind[InlayHintKind[\"Other\"] = 0] = \"Other\";\n    InlayHintKind[InlayHintKind[\"Type\"] = 1] = \"Type\";\n    InlayHintKind[InlayHintKind[\"Parameter\"] = 2] = \"Parameter\";\n})(InlayHintKind || (InlayHintKind = {}));\n/**\n * How an {@link InlineCompletionsProvider inline completion provider} was triggered.\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n    /**\n     * Completion was triggered automatically while editing.\n     * It is sufficient to return a single completion item in this case.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n    /**\n     * Completion was triggered explicitly by a user gesture.\n     * Return multiple completion items to enable cycling through them.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Explicit\"] = 1] = \"Explicit\";\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\n/**\n * Virtual Key Codes, the value does not hold any inherent meaning.\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n * But these are \"more general\", as they should work across browsers & OS`s.\n */\nexport var KeyCode;\n(function (KeyCode) {\n    KeyCode[KeyCode[\"DependsOnKbLayout\"] = -1] = \"DependsOnKbLayout\";\n    /**\n     * Placed first to cover the 0 value of the enum.\n     */\n    KeyCode[KeyCode[\"Unknown\"] = 0] = \"Unknown\";\n    KeyCode[KeyCode[\"Backspace\"] = 1] = \"Backspace\";\n    KeyCode[KeyCode[\"Tab\"] = 2] = \"Tab\";\n    KeyCode[KeyCode[\"Enter\"] = 3] = \"Enter\";\n    KeyCode[KeyCode[\"Shift\"] = 4] = \"Shift\";\n    KeyCode[KeyCode[\"Ctrl\"] = 5] = \"Ctrl\";\n    KeyCode[KeyCode[\"Alt\"] = 6] = \"Alt\";\n    KeyCode[KeyCode[\"PauseBreak\"] = 7] = \"PauseBreak\";\n    KeyCode[KeyCode[\"CapsLock\"] = 8] = \"CapsLock\";\n    KeyCode[KeyCode[\"Escape\"] = 9] = \"Escape\";\n    KeyCode[KeyCode[\"Space\"] = 10] = \"Space\";\n    KeyCode[KeyCode[\"PageUp\"] = 11] = \"PageUp\";\n    KeyCode[KeyCode[\"PageDown\"] = 12] = \"PageDown\";\n    KeyCode[KeyCode[\"End\"] = 13] = \"End\";\n    KeyCode[KeyCode[\"Home\"] = 14] = \"Home\";\n    KeyCode[KeyCode[\"LeftArrow\"] = 15] = \"LeftArrow\";\n    KeyCode[KeyCode[\"UpArrow\"] = 16] = \"UpArrow\";\n    KeyCode[KeyCode[\"RightArrow\"] = 17] = \"RightArrow\";\n    KeyCode[KeyCode[\"DownArrow\"] = 18] = \"DownArrow\";\n    KeyCode[KeyCode[\"Insert\"] = 19] = \"Insert\";\n    KeyCode[KeyCode[\"Delete\"] = 20] = \"Delete\";\n    KeyCode[KeyCode[\"Digit0\"] = 21] = \"Digit0\";\n    KeyCode[KeyCode[\"Digit1\"] = 22] = \"Digit1\";\n    KeyCode[KeyCode[\"Digit2\"] = 23] = \"Digit2\";\n    KeyCode[KeyCode[\"Digit3\"] = 24] = \"Digit3\";\n    KeyCode[KeyCode[\"Digit4\"] = 25] = \"Digit4\";\n    KeyCode[KeyCode[\"Digit5\"] = 26] = \"Digit5\";\n    KeyCode[KeyCode[\"Digit6\"] = 27] = \"Digit6\";\n    KeyCode[KeyCode[\"Digit7\"] = 28] = \"Digit7\";\n    KeyCode[KeyCode[\"Digit8\"] = 29] = \"Digit8\";\n    KeyCode[KeyCode[\"Digit9\"] = 30] = \"Digit9\";\n    KeyCode[KeyCode[\"KeyA\"] = 31] = \"KeyA\";\n    KeyCode[KeyCode[\"KeyB\"] = 32] = \"KeyB\";\n    KeyCode[KeyCode[\"KeyC\"] = 33] = \"KeyC\";\n    KeyCode[KeyCode[\"KeyD\"] = 34] = \"KeyD\";\n    KeyCode[KeyCode[\"KeyE\"] = 35] = \"KeyE\";\n    KeyCode[KeyCode[\"KeyF\"] = 36] = \"KeyF\";\n    KeyCode[KeyCode[\"KeyG\"] = 37] = \"KeyG\";\n    KeyCode[KeyCode[\"KeyH\"] = 38] = \"KeyH\";\n    KeyCode[KeyCode[\"KeyI\"] = 39] = \"KeyI\";\n    KeyCode[KeyCode[\"KeyJ\"] = 40] = \"KeyJ\";\n    KeyCode[KeyCode[\"KeyK\"] = 41] = \"KeyK\";\n    KeyCode[KeyCode[\"KeyL\"] = 42] = \"KeyL\";\n    KeyCode[KeyCode[\"KeyM\"] = 43] = \"KeyM\";\n    KeyCode[KeyCode[\"KeyN\"] = 44] = \"KeyN\";\n    KeyCode[KeyCode[\"KeyO\"] = 45] = \"KeyO\";\n    KeyCode[KeyCode[\"KeyP\"] = 46] = \"KeyP\";\n    KeyCode[KeyCode[\"KeyQ\"] = 47] = \"KeyQ\";\n    KeyCode[KeyCode[\"KeyR\"] = 48] = \"KeyR\";\n    KeyCode[KeyCode[\"KeyS\"] = 49] = \"KeyS\";\n    KeyCode[KeyCode[\"KeyT\"] = 50] = \"KeyT\";\n    KeyCode[KeyCode[\"KeyU\"] = 51] = \"KeyU\";\n    KeyCode[KeyCode[\"KeyV\"] = 52] = \"KeyV\";\n    KeyCode[KeyCode[\"KeyW\"] = 53] = \"KeyW\";\n    KeyCode[KeyCode[\"KeyX\"] = 54] = \"KeyX\";\n    KeyCode[KeyCode[\"KeyY\"] = 55] = \"KeyY\";\n    KeyCode[KeyCode[\"KeyZ\"] = 56] = \"KeyZ\";\n    KeyCode[KeyCode[\"Meta\"] = 57] = \"Meta\";\n    KeyCode[KeyCode[\"ContextMenu\"] = 58] = \"ContextMenu\";\n    KeyCode[KeyCode[\"F1\"] = 59] = \"F1\";\n    KeyCode[KeyCode[\"F2\"] = 60] = \"F2\";\n    KeyCode[KeyCode[\"F3\"] = 61] = \"F3\";\n    KeyCode[KeyCode[\"F4\"] = 62] = \"F4\";\n    KeyCode[KeyCode[\"F5\"] = 63] = \"F5\";\n    KeyCode[KeyCode[\"F6\"] = 64] = \"F6\";\n    KeyCode[KeyCode[\"F7\"] = 65] = \"F7\";\n    KeyCode[KeyCode[\"F8\"] = 66] = \"F8\";\n    KeyCode[KeyCode[\"F9\"] = 67] = \"F9\";\n    KeyCode[KeyCode[\"F10\"] = 68] = \"F10\";\n    KeyCode[KeyCode[\"F11\"] = 69] = \"F11\";\n    KeyCode[KeyCode[\"F12\"] = 70] = \"F12\";\n    KeyCode[KeyCode[\"F13\"] = 71] = \"F13\";\n    KeyCode[KeyCode[\"F14\"] = 72] = \"F14\";\n    KeyCode[KeyCode[\"F15\"] = 73] = \"F15\";\n    KeyCode[KeyCode[\"F16\"] = 74] = \"F16\";\n    KeyCode[KeyCode[\"F17\"] = 75] = \"F17\";\n    KeyCode[KeyCode[\"F18\"] = 76] = \"F18\";\n    KeyCode[KeyCode[\"F19\"] = 77] = \"F19\";\n    KeyCode[KeyCode[\"NumLock\"] = 78] = \"NumLock\";\n    KeyCode[KeyCode[\"ScrollLock\"] = 79] = \"ScrollLock\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ';:' key\n     */\n    KeyCode[KeyCode[\"Semicolon\"] = 80] = \"Semicolon\";\n    /**\n     * For any country/region, the '+' key\n     * For the US standard keyboard, the '=+' key\n     */\n    KeyCode[KeyCode[\"Equal\"] = 81] = \"Equal\";\n    /**\n     * For any country/region, the ',' key\n     * For the US standard keyboard, the ',<' key\n     */\n    KeyCode[KeyCode[\"Comma\"] = 82] = \"Comma\";\n    /**\n     * For any country/region, the '-' key\n     * For the US standard keyboard, the '-_' key\n     */\n    KeyCode[KeyCode[\"Minus\"] = 83] = \"Minus\";\n    /**\n     * For any country/region, the '.' key\n     * For the US standard keyboard, the '.>' key\n     */\n    KeyCode[KeyCode[\"Period\"] = 84] = \"Period\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '/?' key\n     */\n    KeyCode[KeyCode[\"Slash\"] = 85] = \"Slash\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '`~' key\n     */\n    KeyCode[KeyCode[\"Backquote\"] = 86] = \"Backquote\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '[{' key\n     */\n    KeyCode[KeyCode[\"BracketLeft\"] = 87] = \"BracketLeft\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '\\|' key\n     */\n    KeyCode[KeyCode[\"Backslash\"] = 88] = \"Backslash\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ']}' key\n     */\n    KeyCode[KeyCode[\"BracketRight\"] = 89] = \"BracketRight\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ''\"' key\n     */\n    KeyCode[KeyCode[\"Quote\"] = 90] = \"Quote\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     */\n    KeyCode[KeyCode[\"OEM_8\"] = 91] = \"OEM_8\";\n    /**\n     * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n     */\n    KeyCode[KeyCode[\"IntlBackslash\"] = 92] = \"IntlBackslash\";\n    KeyCode[KeyCode[\"Numpad0\"] = 93] = \"Numpad0\";\n    KeyCode[KeyCode[\"Numpad1\"] = 94] = \"Numpad1\";\n    KeyCode[KeyCode[\"Numpad2\"] = 95] = \"Numpad2\";\n    KeyCode[KeyCode[\"Numpad3\"] = 96] = \"Numpad3\";\n    KeyCode[KeyCode[\"Numpad4\"] = 97] = \"Numpad4\";\n    KeyCode[KeyCode[\"Numpad5\"] = 98] = \"Numpad5\";\n    KeyCode[KeyCode[\"Numpad6\"] = 99] = \"Numpad6\";\n    KeyCode[KeyCode[\"Numpad7\"] = 100] = \"Numpad7\";\n    KeyCode[KeyCode[\"Numpad8\"] = 101] = \"Numpad8\";\n    KeyCode[KeyCode[\"Numpad9\"] = 102] = \"Numpad9\";\n    KeyCode[KeyCode[\"NumpadMultiply\"] = 103] = \"NumpadMultiply\";\n    KeyCode[KeyCode[\"NumpadAdd\"] = 104] = \"NumpadAdd\";\n    KeyCode[KeyCode[\"NUMPAD_SEPARATOR\"] = 105] = \"NUMPAD_SEPARATOR\";\n    KeyCode[KeyCode[\"NumpadSubtract\"] = 106] = \"NumpadSubtract\";\n    KeyCode[KeyCode[\"NumpadDecimal\"] = 107] = \"NumpadDecimal\";\n    KeyCode[KeyCode[\"NumpadDivide\"] = 108] = \"NumpadDivide\";\n    /**\n     * Cover all key codes when IME is processing input.\n     */\n    KeyCode[KeyCode[\"KEY_IN_COMPOSITION\"] = 109] = \"KEY_IN_COMPOSITION\";\n    KeyCode[KeyCode[\"ABNT_C1\"] = 110] = \"ABNT_C1\";\n    KeyCode[KeyCode[\"ABNT_C2\"] = 111] = \"ABNT_C2\";\n    KeyCode[KeyCode[\"AudioVolumeMute\"] = 112] = \"AudioVolumeMute\";\n    KeyCode[KeyCode[\"AudioVolumeUp\"] = 113] = \"AudioVolumeUp\";\n    KeyCode[KeyCode[\"AudioVolumeDown\"] = 114] = \"AudioVolumeDown\";\n    KeyCode[KeyCode[\"BrowserSearch\"] = 115] = \"BrowserSearch\";\n    KeyCode[KeyCode[\"BrowserHome\"] = 116] = \"BrowserHome\";\n    KeyCode[KeyCode[\"BrowserBack\"] = 117] = \"BrowserBack\";\n    KeyCode[KeyCode[\"BrowserForward\"] = 118] = \"BrowserForward\";\n    KeyCode[KeyCode[\"MediaTrackNext\"] = 119] = \"MediaTrackNext\";\n    KeyCode[KeyCode[\"MediaTrackPrevious\"] = 120] = \"MediaTrackPrevious\";\n    KeyCode[KeyCode[\"MediaStop\"] = 121] = \"MediaStop\";\n    KeyCode[KeyCode[\"MediaPlayPause\"] = 122] = \"MediaPlayPause\";\n    KeyCode[KeyCode[\"LaunchMediaPlayer\"] = 123] = \"LaunchMediaPlayer\";\n    KeyCode[KeyCode[\"LaunchMail\"] = 124] = \"LaunchMail\";\n    KeyCode[KeyCode[\"LaunchApp2\"] = 125] = \"LaunchApp2\";\n    /**\n     * Placed last to cover the length of the enum.\n     * Please do not depend on this value!\n     */\n    KeyCode[KeyCode[\"MAX_VALUE\"] = 126] = \"MAX_VALUE\";\n})(KeyCode || (KeyCode = {}));\nexport var MarkerSeverity;\n(function (MarkerSeverity) {\n    MarkerSeverity[MarkerSeverity[\"Hint\"] = 1] = \"Hint\";\n    MarkerSeverity[MarkerSeverity[\"Info\"] = 2] = \"Info\";\n    MarkerSeverity[MarkerSeverity[\"Warning\"] = 4] = \"Warning\";\n    MarkerSeverity[MarkerSeverity[\"Error\"] = 8] = \"Error\";\n})(MarkerSeverity || (MarkerSeverity = {}));\nexport var MarkerTag;\n(function (MarkerTag) {\n    MarkerTag[MarkerTag[\"Unnecessary\"] = 1] = \"Unnecessary\";\n    MarkerTag[MarkerTag[\"Deprecated\"] = 2] = \"Deprecated\";\n})(MarkerTag || (MarkerTag = {}));\n/**\n * Position in the minimap to render the decoration.\n */\nexport var MinimapPosition;\n(function (MinimapPosition) {\n    MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\n    MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\n})(MinimapPosition || (MinimapPosition = {}));\n/**\n * Type of hit element with the mouse in the editor.\n */\nexport var MouseTargetType;\n(function (MouseTargetType) {\n    /**\n     * Mouse is on top of an unknown element.\n     */\n    MouseTargetType[MouseTargetType[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n    /**\n     * Mouse is on top of the textarea used for input.\n     */\n    MouseTargetType[MouseTargetType[\"TEXTAREA\"] = 1] = \"TEXTAREA\";\n    /**\n     * Mouse is on top of the glyph margin\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_GLYPH_MARGIN\"] = 2] = \"GUTTER_GLYPH_MARGIN\";\n    /**\n     * Mouse is on top of the line numbers\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_NUMBERS\"] = 3] = \"GUTTER_LINE_NUMBERS\";\n    /**\n     * Mouse is on top of the line decorations\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_DECORATIONS\"] = 4] = \"GUTTER_LINE_DECORATIONS\";\n    /**\n     * Mouse is on top of the whitespace left in the gutter by a view zone.\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_VIEW_ZONE\"] = 5] = \"GUTTER_VIEW_ZONE\";\n    /**\n     * Mouse is on top of text in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_TEXT\"] = 6] = \"CONTENT_TEXT\";\n    /**\n     * Mouse is on top of empty space in the content (e.g. after line text or below last line)\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_EMPTY\"] = 7] = \"CONTENT_EMPTY\";\n    /**\n     * Mouse is on top of a view zone in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_VIEW_ZONE\"] = 8] = \"CONTENT_VIEW_ZONE\";\n    /**\n     * Mouse is on top of a content widget.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_WIDGET\"] = 9] = \"CONTENT_WIDGET\";\n    /**\n     * Mouse is on top of the decorations overview ruler.\n     */\n    MouseTargetType[MouseTargetType[\"OVERVIEW_RULER\"] = 10] = \"OVERVIEW_RULER\";\n    /**\n     * Mouse is on top of a scrollbar.\n     */\n    MouseTargetType[MouseTargetType[\"SCROLLBAR\"] = 11] = \"SCROLLBAR\";\n    /**\n     * Mouse is on top of an overlay widget.\n     */\n    MouseTargetType[MouseTargetType[\"OVERLAY_WIDGET\"] = 12] = \"OVERLAY_WIDGET\";\n    /**\n     * Mouse is outside of the editor.\n     */\n    MouseTargetType[MouseTargetType[\"OUTSIDE_EDITOR\"] = 13] = \"OUTSIDE_EDITOR\";\n})(MouseTargetType || (MouseTargetType = {}));\n/**\n * A positioning preference for rendering overlay widgets.\n */\nexport var OverlayWidgetPositionPreference;\n(function (OverlayWidgetPositionPreference) {\n    /**\n     * Position the overlay widget in the top right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_RIGHT_CORNER\"] = 0] = \"TOP_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the bottom right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"BOTTOM_RIGHT_CORNER\"] = 1] = \"BOTTOM_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the top center\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_CENTER\"] = 2] = \"TOP_CENTER\";\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\nexport var RenderLineNumbersType;\n(function (RenderLineNumbersType) {\n    RenderLineNumbersType[RenderLineNumbersType[\"Off\"] = 0] = \"Off\";\n    RenderLineNumbersType[RenderLineNumbersType[\"On\"] = 1] = \"On\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Relative\"] = 2] = \"Relative\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Interval\"] = 3] = \"Interval\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Custom\"] = 4] = \"Custom\";\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\nexport var RenderMinimap;\n(function (RenderMinimap) {\n    RenderMinimap[RenderMinimap[\"None\"] = 0] = \"None\";\n    RenderMinimap[RenderMinimap[\"Text\"] = 1] = \"Text\";\n    RenderMinimap[RenderMinimap[\"Blocks\"] = 2] = \"Blocks\";\n})(RenderMinimap || (RenderMinimap = {}));\nexport var ScrollType;\n(function (ScrollType) {\n    ScrollType[ScrollType[\"Smooth\"] = 0] = \"Smooth\";\n    ScrollType[ScrollType[\"Immediate\"] = 1] = \"Immediate\";\n})(ScrollType || (ScrollType = {}));\nexport var ScrollbarVisibility;\n(function (ScrollbarVisibility) {\n    ScrollbarVisibility[ScrollbarVisibility[\"Auto\"] = 1] = \"Auto\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Hidden\"] = 2] = \"Hidden\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Visible\"] = 3] = \"Visible\";\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\n/**\n * The direction of a selection.\n */\nexport var SelectionDirection;\n(function (SelectionDirection) {\n    /**\n     * The selection starts above where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"LTR\"] = 0] = \"LTR\";\n    /**\n     * The selection starts below where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"RTL\"] = 1] = \"RTL\";\n})(SelectionDirection || (SelectionDirection = {}));\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n    SymbolKind[SymbolKind[\"File\"] = 0] = \"File\";\n    SymbolKind[SymbolKind[\"Module\"] = 1] = \"Module\";\n    SymbolKind[SymbolKind[\"Namespace\"] = 2] = \"Namespace\";\n    SymbolKind[SymbolKind[\"Package\"] = 3] = \"Package\";\n    SymbolKind[SymbolKind[\"Class\"] = 4] = \"Class\";\n    SymbolKind[SymbolKind[\"Method\"] = 5] = \"Method\";\n    SymbolKind[SymbolKind[\"Property\"] = 6] = \"Property\";\n    SymbolKind[SymbolKind[\"Field\"] = 7] = \"Field\";\n    SymbolKind[SymbolKind[\"Constructor\"] = 8] = \"Constructor\";\n    SymbolKind[SymbolKind[\"Enum\"] = 9] = \"Enum\";\n    SymbolKind[SymbolKind[\"Interface\"] = 10] = \"Interface\";\n    SymbolKind[SymbolKind[\"Function\"] = 11] = \"Function\";\n    SymbolKind[SymbolKind[\"Variable\"] = 12] = \"Variable\";\n    SymbolKind[SymbolKind[\"Constant\"] = 13] = \"Constant\";\n    SymbolKind[SymbolKind[\"String\"] = 14] = \"String\";\n    SymbolKind[SymbolKind[\"Number\"] = 15] = \"Number\";\n    SymbolKind[SymbolKind[\"Boolean\"] = 16] = \"Boolean\";\n    SymbolKind[SymbolKind[\"Array\"] = 17] = \"Array\";\n    SymbolKind[SymbolKind[\"Object\"] = 18] = \"Object\";\n    SymbolKind[SymbolKind[\"Key\"] = 19] = \"Key\";\n    SymbolKind[SymbolKind[\"Null\"] = 20] = \"Null\";\n    SymbolKind[SymbolKind[\"EnumMember\"] = 21] = \"EnumMember\";\n    SymbolKind[SymbolKind[\"Struct\"] = 22] = \"Struct\";\n    SymbolKind[SymbolKind[\"Event\"] = 23] = \"Event\";\n    SymbolKind[SymbolKind[\"Operator\"] = 24] = \"Operator\";\n    SymbolKind[SymbolKind[\"TypeParameter\"] = 25] = \"TypeParameter\";\n})(SymbolKind || (SymbolKind = {}));\nexport var SymbolTag;\n(function (SymbolTag) {\n    SymbolTag[SymbolTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(SymbolTag || (SymbolTag = {}));\n/**\n * The kind of animation in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorBlinkingStyle;\n(function (TextEditorCursorBlinkingStyle) {\n    /**\n     * Hidden\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Hidden\"] = 0] = \"Hidden\";\n    /**\n     * Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Blink\"] = 1] = \"Blink\";\n    /**\n     * Blinking with smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Smooth\"] = 2] = \"Smooth\";\n    /**\n     * Blinking with prolonged filled state and smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Phase\"] = 3] = \"Phase\";\n    /**\n     * Expand collapse animation on the y axis\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Expand\"] = 4] = \"Expand\";\n    /**\n     * No-Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Solid\"] = 5] = \"Solid\";\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\n/**\n * The style in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorStyle;\n(function (TextEditorCursorStyle) {\n    /**\n     * As a vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Line\"] = 1] = \"Line\";\n    /**\n     * As a block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Block\"] = 2] = \"Block\";\n    /**\n     * As a horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Underline\"] = 3] = \"Underline\";\n    /**\n     * As a thin vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"LineThin\"] = 4] = \"LineThin\";\n    /**\n     * As an outlined block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"BlockOutline\"] = 5] = \"BlockOutline\";\n    /**\n     * As a thin horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"UnderlineThin\"] = 6] = \"UnderlineThin\";\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\n/**\n * Describes the behavior of decorations when typing/editing near their edges.\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\n */\nexport var TrackedRangeStickiness;\n(function (TrackedRangeStickiness) {\n    TrackedRangeStickiness[TrackedRangeStickiness[\"AlwaysGrowsWhenTypingAtEdges\"] = 0] = \"AlwaysGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"NeverGrowsWhenTypingAtEdges\"] = 1] = \"NeverGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingBefore\"] = 2] = \"GrowsOnlyWhenTypingBefore\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingAfter\"] = 3] = \"GrowsOnlyWhenTypingAfter\";\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\n/**\n * Describes how to indent wrapped lines.\n */\nexport var WrappingIndent;\n(function (WrappingIndent) {\n    /**\n     * No indentation => wrapped lines begin at column 1.\n     */\n    WrappingIndent[WrappingIndent[\"None\"] = 0] = \"None\";\n    /**\n     * Same => wrapped lines get the same indentation as the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Same\"] = 1] = \"Same\";\n    /**\n     * Indent => wrapped lines get +1 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Indent\"] = 2] = \"Indent\";\n    /**\n     * DeepIndent => wrapped lines get +2 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"DeepIndent\"] = 3] = \"DeepIndent\";\n})(WrappingIndent || (WrappingIndent = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport class Selection extends Range {\n    constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n        super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);\n        this.selectionStartLineNumber = selectionStartLineNumber;\n        this.selectionStartColumn = selectionStartColumn;\n        this.positionLineNumber = positionLineNumber;\n        this.positionColumn = positionColumn;\n    }\n    /**\n     * Transform to a human-readable representation.\n     */\n    toString() {\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n    }\n    /**\n     * Test if equals other selection.\n     */\n    equalsSelection(other) {\n        return (Selection.selectionsEqual(this, other));\n    }\n    /**\n     * Test if the two selections are equal.\n     */\n    static selectionsEqual(a, b) {\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n            a.selectionStartColumn === b.selectionStartColumn &&\n            a.positionLineNumber === b.positionLineNumber &&\n            a.positionColumn === b.positionColumn);\n    }\n    /**\n     * Get directions (LTR or RTL).\n     */\n    getDirection() {\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n            return 0 /* LTR */;\n        }\n        return 1 /* RTL */;\n    }\n    /**\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n    }\n    /**\n     * Get the position at `positionLineNumber` and `positionColumn`.\n     */\n    getPosition() {\n        return new Position(this.positionLineNumber, this.positionColumn);\n    }\n    /**\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n        }\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n    }\n    // ----\n    /**\n     * Create a `Selection` from one or two positions\n     */\n    static fromPositions(start, end = start) {\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    /**\n     * Create a `Selection` from an `ISelection`.\n     */\n    static liftSelection(sel) {\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n    }\n    /**\n     * `a` equals `b`.\n     */\n    static selectionsArrEqual(a, b) {\n        if (a && !b || !a && b) {\n            return false;\n        }\n        if (!a && !b) {\n            return true;\n        }\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (let i = 0, len = a.length; i < len; i++) {\n            if (!this.selectionsEqual(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Test if `obj` is an `ISelection`.\n     */\n    static isISelection(obj) {\n        return (obj\n            && (typeof obj.selectionStartLineNumber === 'number')\n            && (typeof obj.selectionStartColumn === 'number')\n            && (typeof obj.positionLineNumber === 'number')\n            && (typeof obj.positionColumn === 'number'));\n    }\n    /**\n     * Create with a direction.\n     */\n    static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n        if (direction === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Token {\n    constructor(offset, type, language) {\n        this._tokenBrand = undefined;\n        this.offset = offset | 0; // @perf\n        this.type = type;\n        this.language = language;\n    }\n    toString() {\n        return '(' + this.offset + ', ' + this.type + ')';\n    }\n}\nexport class TokenizationResult {\n    constructor(tokens, endState) {\n        this._tokenizationResultBrand = undefined;\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n}\nexport class TokenizationResult2 {\n    constructor(tokens, endState) {\n        this._tokenizationResult2Brand = undefined;\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CancellationTokenSource } from '../../../base/common/cancellation.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { KeyChord } from '../../../base/common/keyCodes.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { Token } from '../core/token.js';\nimport * as standaloneEnums from './standaloneEnums.js';\nexport class KeyMod {\n    static chord(firstPart, secondPart) {\n        return KeyChord(firstPart, secondPart);\n    }\n}\nKeyMod.CtrlCmd = 2048 /* CtrlCmd */;\nKeyMod.Shift = 1024 /* Shift */;\nKeyMod.Alt = 512 /* Alt */;\nKeyMod.WinCtrl = 256 /* WinCtrl */;\nexport function createMonacoBaseAPI() {\n    return {\n        editor: undefined,\n        languages: undefined,\n        CancellationTokenSource: CancellationTokenSource,\n        Emitter: Emitter,\n        KeyCode: standaloneEnums.KeyCode,\n        KeyMod: KeyMod,\n        Position: Position,\n        Range: Range,\n        Selection: Selection,\n        SelectionDirection: standaloneEnums.SelectionDirection,\n        MarkerSeverity: standaloneEnums.MarkerSeverity,\n        MarkerTag: standaloneEnums.MarkerTag,\n        Uri: URI,\n        Token: Token\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { stringDiff } from '../../../base/common/diff/diff.js';\nimport { globals } from '../../../base/common/platform.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { DiffComputer } from '../diff/diffComputer.js';\nimport { MirrorTextModel as BaseMirrorModel } from '../model/mirrorTextModel.js';\nimport { ensureValidWordDefinition, getWordAtText } from '../model/wordHelper.js';\nimport { computeLinks } from '../modes/linkComputer.js';\nimport { BasicInplaceReplace } from '../modes/supports/inplaceReplaceSupport.js';\nimport { createMonacoBaseAPI } from '../standalone/standaloneBase.js';\nimport * as types from '../../../base/common/types.js';\nimport { StopWatch } from '../../../base/common/stopwatch.js';\n/**\n * @internal\n */\nexport class MirrorModel extends BaseMirrorModel {\n    get uri() {\n        return this._uri;\n    }\n    get eol() {\n        return this._eol;\n    }\n    getValue() {\n        return this.getText();\n    }\n    getLinesContent() {\n        return this._lines.slice(0);\n    }\n    getLineCount() {\n        return this._lines.length;\n    }\n    getLineContent(lineNumber) {\n        return this._lines[lineNumber - 1];\n    }\n    getWordAtPosition(position, wordDefinition) {\n        let wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);\n        if (wordAtText) {\n            return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n        }\n        return null;\n    }\n    words(wordDefinition) {\n        const lines = this._lines;\n        const wordenize = this._wordenize.bind(this);\n        let lineNumber = 0;\n        let lineText = '';\n        let wordRangesIdx = 0;\n        let wordRanges = [];\n        return {\n            *[Symbol.iterator]() {\n                while (true) {\n                    if (wordRangesIdx < wordRanges.length) {\n                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n                        wordRangesIdx += 1;\n                        yield value;\n                    }\n                    else {\n                        if (lineNumber < lines.length) {\n                            lineText = lines[lineNumber];\n                            wordRanges = wordenize(lineText, wordDefinition);\n                            wordRangesIdx = 0;\n                            lineNumber += 1;\n                        }\n                        else {\n                            break;\n                        }\n                    }\n                }\n            }\n        };\n    }\n    getLineWords(lineNumber, wordDefinition) {\n        let content = this._lines[lineNumber - 1];\n        let ranges = this._wordenize(content, wordDefinition);\n        let words = [];\n        for (const range of ranges) {\n            words.push({\n                word: content.substring(range.start, range.end),\n                startColumn: range.start + 1,\n                endColumn: range.end + 1\n            });\n        }\n        return words;\n    }\n    _wordenize(content, wordDefinition) {\n        const result = [];\n        let match;\n        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n        while (match = wordDefinition.exec(content)) {\n            if (match[0].length === 0) {\n                // it did match the empty string\n                break;\n            }\n            result.push({ start: match.index, end: match.index + match[0].length });\n        }\n        return result;\n    }\n    getValueInRange(range) {\n        range = this._validateRange(range);\n        if (range.startLineNumber === range.endLineNumber) {\n            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n        }\n        let lineEnding = this._eol;\n        let startLineIndex = range.startLineNumber - 1;\n        let endLineIndex = range.endLineNumber - 1;\n        let resultLines = [];\n        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n        for (let i = startLineIndex + 1; i < endLineIndex; i++) {\n            resultLines.push(this._lines[i]);\n        }\n        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n        return resultLines.join(lineEnding);\n    }\n    offsetAt(position) {\n        position = this._validatePosition(position);\n        this._ensureLineStarts();\n        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);\n    }\n    positionAt(offset) {\n        offset = Math.floor(offset);\n        offset = Math.max(0, offset);\n        this._ensureLineStarts();\n        let out = this._lineStarts.getIndexOf(offset);\n        let lineLength = this._lines[out.index].length;\n        // Ensure we return a valid position\n        return {\n            lineNumber: 1 + out.index,\n            column: 1 + Math.min(out.remainder, lineLength)\n        };\n    }\n    _validateRange(range) {\n        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n        if (start.lineNumber !== range.startLineNumber\n            || start.column !== range.startColumn\n            || end.lineNumber !== range.endLineNumber\n            || end.column !== range.endColumn) {\n            return {\n                startLineNumber: start.lineNumber,\n                startColumn: start.column,\n                endLineNumber: end.lineNumber,\n                endColumn: end.column\n            };\n        }\n        return range;\n    }\n    _validatePosition(position) {\n        if (!Position.isIPosition(position)) {\n            throw new Error('bad position');\n        }\n        let { lineNumber, column } = position;\n        let hasChanged = false;\n        if (lineNumber < 1) {\n            lineNumber = 1;\n            column = 1;\n            hasChanged = true;\n        }\n        else if (lineNumber > this._lines.length) {\n            lineNumber = this._lines.length;\n            column = this._lines[lineNumber - 1].length + 1;\n            hasChanged = true;\n        }\n        else {\n            let maxCharacter = this._lines[lineNumber - 1].length + 1;\n            if (column < 1) {\n                column = 1;\n                hasChanged = true;\n            }\n            else if (column > maxCharacter) {\n                column = maxCharacter;\n                hasChanged = true;\n            }\n        }\n        if (!hasChanged) {\n            return position;\n        }\n        else {\n            return { lineNumber, column };\n        }\n    }\n}\n/**\n * @internal\n */\nexport class EditorSimpleWorker {\n    constructor(host, foreignModuleFactory) {\n        this._host = host;\n        this._models = Object.create(null);\n        this._foreignModuleFactory = foreignModuleFactory;\n        this._foreignModule = null;\n    }\n    dispose() {\n        this._models = Object.create(null);\n    }\n    _getModel(uri) {\n        return this._models[uri];\n    }\n    _getModels() {\n        let all = [];\n        Object.keys(this._models).forEach((key) => all.push(this._models[key]));\n        return all;\n    }\n    acceptNewModel(data) {\n        this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\n    }\n    acceptModelChanged(strURL, e) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        let model = this._models[strURL];\n        model.onEvents(e);\n    }\n    acceptRemovedModel(strURL) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        delete this._models[strURL];\n    }\n    // ---- BEGIN diff --------------------------------------------------------------------------\n    computeDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace, maxComputationTime) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const original = this._getModel(originalUrl);\n            const modified = this._getModel(modifiedUrl);\n            if (!original || !modified) {\n                return null;\n            }\n            const originalLines = original.getLinesContent();\n            const modifiedLines = modified.getLinesContent();\n            const diffComputer = new DiffComputer(originalLines, modifiedLines, {\n                shouldComputeCharChanges: true,\n                shouldPostProcessCharChanges: true,\n                shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n                shouldMakePrettyDiff: true,\n                maxComputationTime: maxComputationTime\n            });\n            const diffResult = diffComputer.computeDiff();\n            const identical = (diffResult.changes.length > 0 ? false : this._modelsAreIdentical(original, modified));\n            return {\n                quitEarly: diffResult.quitEarly,\n                identical: identical,\n                changes: diffResult.changes\n            };\n        });\n    }\n    _modelsAreIdentical(original, modified) {\n        const originalLineCount = original.getLineCount();\n        const modifiedLineCount = modified.getLineCount();\n        if (originalLineCount !== modifiedLineCount) {\n            return false;\n        }\n        for (let line = 1; line <= originalLineCount; line++) {\n            const originalLine = original.getLineContent(line);\n            const modifiedLine = modified.getLineContent(line);\n            if (originalLine !== modifiedLine) {\n                return false;\n            }\n        }\n        return true;\n    }\n    computeMoreMinimalEdits(modelUrl, edits) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const model = this._getModel(modelUrl);\n            if (!model) {\n                return edits;\n            }\n            const result = [];\n            let lastEol = undefined;\n            edits = edits.slice(0).sort((a, b) => {\n                if (a.range && b.range) {\n                    return Range.compareRangesUsingStarts(a.range, b.range);\n                }\n                // eol only changes should go to the end\n                let aRng = a.range ? 0 : 1;\n                let bRng = b.range ? 0 : 1;\n                return aRng - bRng;\n            });\n            for (let { range, text, eol } of edits) {\n                if (typeof eol === 'number') {\n                    lastEol = eol;\n                }\n                if (Range.isEmpty(range) && !text) {\n                    // empty change\n                    continue;\n                }\n                const original = model.getValueInRange(range);\n                text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n                if (original === text) {\n                    // noop\n                    continue;\n                }\n                // make sure diff won't take too long\n                if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {\n                    result.push({ range, text });\n                    continue;\n                }\n                // compute diff between original and edit.text\n                const changes = stringDiff(original, text, false);\n                const editOffset = model.offsetAt(Range.lift(range).getStartPosition());\n                for (const change of changes) {\n                    const start = model.positionAt(editOffset + change.originalStart);\n                    const end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n                    const newEdit = {\n                        text: text.substr(change.modifiedStart, change.modifiedLength),\n                        range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n                    };\n                    if (model.getValueInRange(newEdit.range) !== newEdit.text) {\n                        result.push(newEdit);\n                    }\n                }\n            }\n            if (typeof lastEol === 'number') {\n                result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\n            }\n            return result;\n        });\n    }\n    // ---- END minimal edits ---------------------------------------------------------------\n    computeLinks(modelUrl) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return null;\n            }\n            return computeLinks(model);\n        });\n    }\n    textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const sw = new StopWatch(true);\n            const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            const seen = new Set();\n            outer: for (let url of modelUrls) {\n                const model = this._getModel(url);\n                if (!model) {\n                    continue;\n                }\n                for (let word of model.words(wordDefRegExp)) {\n                    if (word === leadingWord || !isNaN(Number(word))) {\n                        continue;\n                    }\n                    seen.add(word);\n                    if (seen.size > EditorSimpleWorker._suggestionsLimit) {\n                        break outer;\n                    }\n                }\n            }\n            return { words: Array.from(seen), duration: sw.elapsed() };\n        });\n    }\n    // ---- END suggest --------------------------------------------------------------------------\n    //#region -- word ranges --\n    computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return Object.create(null);\n            }\n            const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            const result = Object.create(null);\n            for (let line = range.startLineNumber; line < range.endLineNumber; line++) {\n                let words = model.getLineWords(line, wordDefRegExp);\n                for (const word of words) {\n                    if (!isNaN(Number(word.word))) {\n                        continue;\n                    }\n                    let array = result[word.word];\n                    if (!array) {\n                        array = [];\n                        result[word.word] = array;\n                    }\n                    array.push({\n                        startLineNumber: line,\n                        startColumn: word.startColumn,\n                        endLineNumber: line,\n                        endColumn: word.endColumn\n                    });\n                }\n            }\n            return result;\n        });\n    }\n    //#endregion\n    navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return null;\n            }\n            let wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            if (range.startColumn === range.endColumn) {\n                range = {\n                    startLineNumber: range.startLineNumber,\n                    startColumn: range.startColumn,\n                    endLineNumber: range.endLineNumber,\n                    endColumn: range.endColumn + 1\n                };\n            }\n            let selectionText = model.getValueInRange(range);\n            let wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n            if (!wordRange) {\n                return null;\n            }\n            let word = model.getValueInRange(wordRange);\n            let result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n            return result;\n        });\n    }\n    // ---- BEGIN foreign module support --------------------------------------------------------------------------\n    loadForeignModule(moduleId, createData, foreignHostMethods) {\n        const proxyMethodRequest = (method, args) => {\n            return this._host.fhr(method, args);\n        };\n        const foreignHost = types.createProxyObject(foreignHostMethods, proxyMethodRequest);\n        let ctx = {\n            host: foreignHost,\n            getMirrorModels: () => {\n                return this._getModels();\n            }\n        };\n        if (this._foreignModuleFactory) {\n            this._foreignModule = this._foreignModuleFactory(ctx, createData);\n            // static foreing module\n            return Promise.resolve(types.getAllMethodNames(this._foreignModule));\n        }\n        // ESM-comment-begin\n        // \t\treturn new Promise<any>((resolve, reject) => {\n        // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n        // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n        // \n        // \t\t\t\tresolve(types.getAllMethodNames(this._foreignModule));\n        // \n        // \t\t\t}, reject);\n        // \t\t});\n        // ESM-comment-end\n        // ESM-uncomment-begin\n        return Promise.reject(new Error(`Unexpected usage`));\n        // ESM-uncomment-end\n    }\n    // foreign method request\n    fmr(method, args) {\n        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    }\n}\n// ---- END diff --------------------------------------------------------------------------\n// ---- BEGIN minimal edits ---------------------------------------------------------------\nEditorSimpleWorker._diffLimit = 100000;\n// ---- BEGIN suggest --------------------------------------------------------------------------\nEditorSimpleWorker._suggestionsLimit = 10000;\n/**\n * Called on the worker side\n * @internal\n */\nexport function create(host) {\n    return new EditorSimpleWorker(host, null);\n}\nif (typeof importScripts === 'function') {\n    // Running in a web worker\n    globals.monaco = createMonacoBaseAPI();\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';\nimport { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';\nlet initialized = false;\nexport function initialize(foreignModule) {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    const simpleWorker = new SimpleWorkerServer((msg) => {\n        self.postMessage(msg);\n    }, (host) => new EditorSimpleWorker(host, foreignModule));\n    self.onmessage = (e) => {\n        simpleWorker.onmessage(e.data);\n    };\n}\nself.onmessage = (e) => {\n    // Ignore first message in this case and initialize if not yet initialized\n    if (!initialized) {\n        initialize(null);\n    }\n};\n"],"sourceRoot":""}