You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 lines
662 KiB
1 lines
662 KiB
{"version":3,"sources":["vs/base/worker/fake","vs/base/worker/vs/loader.js","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/diff/diffChange.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/diff/diff.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/functional.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/keyCodes.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/lifecycle.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/linkedList.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/platform.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/uri.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/map.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/strings.ts","vs/base/worker/vs/base/common/winjs.base.js","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/errors.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/event.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/cancellation.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/async.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/common/worker/simpleWorker.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/position.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/range.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/selection.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/token.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/uint.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/core/characterClassifier.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/diff/diffComputer.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/model/wordHelper.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/modes/linkComputer.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/modes/supports/inplaceReplaceSupport.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/standalone/standaloneBase.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/viewModel/prefixSumComputer.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/model/mirrorTextModel.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/editor/common/services/editorSimpleWorker.ts","vs/base/worker/file:/Users/penlv/code/vscode/src/vs/base/worker/workerMain.ts"],"names":["__m","__M","deps","result","i","len","length","_amdLoaderGlobal","this","AMDLoader","global","Environment","_detected","_isWindows","_isNode","_isElectronRenderer","_isWebWorker","Object","defineProperty","prototype","get","_detect","enumerable","configurable","module","exports","process","versions","electron","type","importScripts","navigator","userAgent","indexOf","platform","LoaderEvent","detail","timestamp","LoaderEventRecorder","loaderAvailableTimestamp","_events","record","push","Utilities","getHighPerformanceTimestamp","getEvents","NullLoaderEventRecorder","INSTANCE","fileUriToFilePath","isWindows","uri","decodeURI","test","substr","startsWith","haystack","needle","endsWith","containsQueryString","url","isAbsolutePath","forEachProperty","obj","callback","key","hasOwnProperty","isEmpty","recursiveClone","Array","isArray","value","generateAnonymousModule","NEXT_ANONYMOUS_ID","isAnonymousModule","id","PERFORMANCE_NOW_PROBED","HAS_PERFORMANCE_NOW","performance","now","Date","ConfigurationOptionsUtil","validateConfigurationOptions","options","defaultOnError","err","errorCode","console","error","moduleId","stack","neededBy","baseUrl","isBuild","paths","config","catchError","urlArgs","onError","ignoreDuplicateModules","nodeModules","nodeCachedDataWriteDelay","onNodeCachedData","data","warn","path","mergeConfigurationOptions","overwrite","base","concat","key2","value2","Configuration","env","_env","_createIgnoreDuplicateModulesMap","_createNodeModulesMap","_createSortedPathsRules","nodeRequire","main","filename","isNode","nodeMain","dirnameIndex","Math","max","lastIndexOf","substring","ignoreDuplicateModulesMap","nodeModulesMap","create","_i","_a","nodeModule","_this","sortedPathsRules","from","to","sort","a","b","cloneAndMerge","getOptionsLiteral","_applyPaths","pathRule","j","lenJ","_addUrlArgsToUrl","_addUrlArgsIfNecessaryToUrl","_addUrlArgsIfNecessaryToUrls","urls","moduleIdToPaths","results","requireToUrl","isDuplicateMessageIgnoredFor","getConfigForModule","shouldCatchError","shouldRecordStats","recordStats","OnlyOnceScriptLoader","_scriptLoader","_callbackMap","load","moduleManager","scriptSrc","errorback","isWebWorker","WorkerScriptLoader","NodeScriptLoader","BrowserScriptLoader","scriptCallbacks","triggerCallback","triggerErrorback","attachListeners","script","unbind","removeEventListener","loadEventListener","errorEventListener","e","addEventListener","document","createElement","setAttribute","getElementsByTagName","appendChild","_didInitialize","_didPatchNodeRequire","_init","_fs","_vm","_path","_crypto","_jsflags","argv","arg","_initNodeRequire","nodeCachedDataDir","getConfig","that","Module","_compile","content","replace","wrapper","wrap","cachedDataPath","_getCachedDataPath","cachedData","readFileSync","produceCachedData","Script","compileWrapper","runInThisContext","dirname","require","mod","constructor","resolve","request","_resolveFilename","mainModule","extensions","_extensions","cache","_cache","makeRequireFunction","args","Buffer","apply","_processCachedData","opts","nodeInstrumenter","c","recorder","getRecorder","pieces","split","moduleExports_1","enqueueDefineAnonymousModule","readFile","encoding","normalizedScriptSrc","normalize","vmScriptSrc","isElectronRenderer","driveLetterMatch","match","toUpperCase","contents","prefix","charCodeAt","_BOM","cachedDataPath_1","_loadAndEvalScript","call","getGlobalAMDRequireFunc","getGlobalAMDDefineFunc","basedir","hash","createHash","update","digest","basename","join","cachedDataRejected","_runSoon","unlink","cachedDataProduced","undefined","writeFile","minTimeout","timeout","ceil","random","setTimeout","createScriptLoader","ModuleIdResolver","fromModuleId","lastSlash","fromModulePath","_normalizeModuleId","pattern","r","resolveModule","ROOT","strId","dependencies","moduleIdResolver","_callback","_errorback","exportsPassedIn","unresolvedDependenciesCount","_isComplete","_safeInvokeFunction","returnedValue","producedError","_invokeFactory","strModuleId","dependenciesValues","complete","onDependencyError","isComplete","ModuleIdProvider","_nextId","_strModuleIdToIntModuleId","Map","_intModuleIdToStrModuleId","getModuleId","getMaxModuleId","set","getStrModuleId","RegularDependency","EXPORTS","MODULE","REQUIRE","PluginDependency","pluginId","pluginParam","ModuleManager","scriptLoader","defineFunc","requireFunc","_loaderAvailableTimestamp","_defineFunc","_requireFunc","_moduleIdProvider","_config","_modules2","_knownModules2","_inverseDependencies2","_inversePluginDependencies2","_currentAnnonymousDefineCall","_recorder","_buildInfoPath","_buildInfoDefineStack","_buildInfoDependencies","reset","_findRelevantLocationInStack","str","normalizedPath","stackPieces","m","stackPath","stackLine","stackColumn","trimPathOffset","line","parseInt","col","Error","getBuildInfo","resultLen","location_1","defineStack","defineLocation","shim","getLoaderEvents","defineModule","_normalizeDependencies","map","dep","_resolve","_normalizeDependency","dependency","bangIndex","strPluginId","dependencyId","_relativeRequire","synchronousRequire","_strModuleId","configure","params","shouldOverwrite","oldShouldRecordStats","_onLoad","defineCall","_createLoadError","intModuleId","_onLoadError","seenModuleId","someoneNotified","queue","queueElement","shift","inverseDeps","inverseDep","_hasDependencyPath","fromId","toId","inQueue","dependencyModule","_findCyclePath","depth","_createRequire","toUrl","getStats","__$__nodeRequire","_loadModule","lastPathIndex","loadNextPath","currentPath_1","recorder_1","_loadPluginDependency","plugin","pluginDependency","cyclePath","reverse","inversePluginDeps","_onModuleComplete","inverseDependencyId","inverseDependency","delete","define","init","_nodeRequire_1","what","RequireFunc","DefineFunc","amd","jQuery","_requireFunc_config","arguments","doNotInitLoader","DiffChange","originalStart","originalLength","modifiedStart","modifiedLength","getOriginalEnd","getModifiedEnd","createStringSequence","getLength","getElementHash","pos","stringDiff","original","modified","pretty","LcsDiff","ComputeDiff","Debug","Assert","condition","message","MyArray","Copy","sourceArray","sourceIndex","destinationArray","destinationIndex","DiffChangeHelper","m_changes","m_originalStart","Number","MAX_VALUE","m_modifiedStart","m_originalCount","m_modifiedCount","MarkNextChange","diffChange_1","AddOriginalElement","originalIndex","modifiedIndex","min","AddModifiedElement","getChanges","getReverseChanges","originalSequence","newSequence","continueProcessingPredicate","OriginalSequence","ModifiedSequence","ContinueProcessingPredicate","m_originalIds","m_modifiedIds","m_forwardHistory","m_reverseHistory","ComputeUniqueIdentifiers","originalSequenceLength","modifiedSequenceLength","hashTable","currentUniqueId","originalElementHash","modifiedElementHash","ElementsAreEqual","newIndex","OriginalElementsAreEqual","index1","index2","ModifiedElementsAreEqual","_ComputeDiff","originalEnd","modifiedEnd","changes","ComputeDiffRecursive","ShiftChanges","quitEarlyArr","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","WALKTRACE","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","diagonal","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","MIN_VALUE","historyIndex","originalStartPoint","modifiedStartPoint","lastForwardChange","numDifferences","maxDifferences","numDiagonals","tempOriginalIndex","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","abs","matchLengthOfLongest","temp","mergedDiffs","change","originalStop","modifiedStop","checkOriginal","checkModified","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","delta","score","_OriginalIsBoundary","index","_OriginalRegionIsBoundary","_ModifiedIsBoundary","_ModifiedRegionIsBoundary","left","right","diagonalBaseIndex","diagonalsAbove","diffEven","once","fn","didCall","createSimpleKeybinding","keybinding","OS","ctrlCmd","winCtrl","SimpleKeybinding","KeyCode","KeyCodeStrMap","_keyCodeToStr","_strToKeyCode","keyCode","toLowerCase","keyCodeToStr","strToKeyCode","uiMap","userSettingsUSMap","userSettingsGeneralMap","uiLabel","usUserSettingsLabel","generalUserSettingsLabel","KeyCodeUtils","toString","fromString","toUserSettingsUS","toUserSettingsGeneral","fromUserSettings","BinaryKeybindingsMask","KeyMod","KeyChord","firstPart","secondPart","createKeybinding","chordPart","ChordKeybinding","KeybindingType","ctrlKey","shiftKey","altKey","metaKey","equals","other","getHashCode","isModifierKey","isDuplicateModifierCase","ResolvedKeybindingPart","kbLabel","kbAriaLabel","keyLabel","keyAriaLabel","ResolvedKeybinding","dispose","first","rest","forEach","d","empty","freeze","isDisposable","thing","combinedDisposable","disposables","toDisposable","fns","fns_1","Disposable","_toDispose","_register","t","ReferenceCollection","references","acquire","reference","counter","object","createReferencedObject","functional_1","destroyReferencedObject","ImmortalReference","Node","element","LinkedList","_first","clear","_last","unshift","insert","atTheEnd","newNode","oldLast","prev","next","oldFirst","candidate","anchor","iterator","done","node","toArray","_isMacintosh","_isLinux","_isNative","_isWeb","_locale","_language","_translationsConfigFile","LANGUAGE_DEFAULT","nextTick","rawNlsConfig","nlsConfig","JSON","parse","resolved","availableLanguages","locale","language","Platform","_platform","Web","Mac","Windows","Linux","isMacintosh","isLinux","isNative","isWeb","isRootUser","getuid","translationsConfigFile","_globals","self","globals","_setImmediate","setImmediate","bind","OperatingSystem","AccessibilitySupport","_encode","ch","_makeFsPath","authority","scheme","_driveLetterPath","_asFormatted","skipEncoding","encoder","encodeURIComponent","parts","query","fragment","idx","userinfo","_upperCaseDrive","exec","lastIdx","_slash","_empty","_schemePattern","_singleSlashStart","_doubleSlashStart","_regexp","_driveLetter","URI","schemeOrData","ret","_validateUri","isUri","with","_URI","decodeURIComponent","file","components","toJSON","res","$mid","fsPath","external","revive","_fsPath","_formatted","_super","__extends","values","forEachable","keys","getOrSet","StringIterator","_value","_pos","hasNext","cmp","PathIterator","_from","_to","justSeps","_fwd","_bwd","aPos","aLen","thisPos","TernarySearchTreeNode","mid","TernarySearchTree","segments","_iter","forPaths","forStrings","_root","iter","val","oldElement","pop","dir","parent_1","findSubstr","findSuperstr","_forEach","ResourceMap","ignoreCase","resource","toKey","has","size","clb","uri_1","default","Touch","LinkedMap","_map","_head","_tail","_size","touch","None","item","previous","addItemLast","AsOld","addItemFirst","AsNew","remove","removeItem","callbackfn","thisArg","current","trimOld","newSize","currentSize","fromJSON","data_1","LRUCache","limit","ratio","_limit","_ratio","checkTrim","peek","round","escapeRegExpCharacters","ltrim","needleLen","offset","rtrim","haystackLen","form","normalizedCache","canNormalize","cached","nonAsciiCharactersPattern","compare","isLowerAsciiLetter","code","isUpperAsciiLetter","isAsciiLetter","doEqualsIgnoreCase","stopAt","codeA","codeB","diff","String","fromCharCode","substrEquals","aStart","aEnd","bStart","bEnd","isFullWidthCharacter","charCode","startsWithUTF8BOM","isFalsyOrWhitespace","trim","pad","n","l","char","_formatRegexp","format","group","isNaN","escape","html","convertSimple2RegExpPattern","stripWildcards","createRegExp","searchString","isRegex","wholeWord","charAt","modifiers","matchCase","multiline","RegExp","regExpLeadsToEndlessLoop","regexp","source","lastIndex","regExpContainsBackreference","regexpValue","nfcCache","map_1","normalizeNFC","nfdCache","normalizeNFD","firstNonWhitespaceIndex","chCode","getLeadingWhitespace","start","end","lastNonWhitespaceIndex","startIndex","compareIgnoreCase","equalsIgnoreCase","startsWithIgnoreCase","candidateLength","commonPrefixLength","commonSuffixLength","aLastIndex","bLastIndex","overlap","isHighSurrogate","isLowSurrogate","CONTAINS_RTL","containsRTL","CONTAINS_EMOJI","containsEmoji","IS_BASIC_ASCII","isBasicASCII","containsFullWidthCharacter","lcut","text","re","EL","COLOR_START","COLOR_END","removeAnsiEscapeCodes","UTF8_BOM_CHARACTER","stripUTF8BOM","safeBtoa","btoa","repeat","s","count","fuzzyContains","target","queryLen","targetLower","containsUppercaseCharacter","ignoreEscapedChars","__winjs_exports","_modules","_winjs","factory","depsValues","window","_Global","actualSetImmediate","hasWinRT","markSupportedForProcessing","func","supportedForProcessing","msWriteProfilerMark","_WinJS","_BaseCoreUtils","_WriteProfilerMark","initializeProperties","members","properties","member","writable","setName","defineProperties","createNamespace","parentNamespace","name","currentNamespace","namespaceFragments","splice","namespaceName","defineWithParent","_rootNamespace","Namespace","LazyStates","uninitialized","working","initialized","_lazy","f","state","_moduleDefine","publicNS","instanceMembers","staticMembers","derive","baseClass","basePrototype","mix","Class","_Base","ErrorFromName","createEventProperty","eventPropStateName","userHandler","handler","evt","EventMixinEvent","timeStamp","bubbles","cancelable","currentTarget","defaultPrevented","_preventDefaultCalled","trusted","eventPhase","preventDefault","stopImmediatePropagation","_stopImmediatePropagationCalled","stopPropagation","eventMixin","_listeners","listener","useCapture","eventListeners","dispatchEvent","details","listeners","eventValue","slice","_createEventProperty","createEventProperties","props","nop","v","_traceAsyncOperationStarting","msTraceAsyncOperationStarting","_traceAsyncOperationCompleted","msTraceAsyncOperationCompleted","_traceAsyncCallbackStarting","msTraceAsyncCallbackStarting","_traceAsyncCallbackCompleted","msTraceAsyncCallbackCompleted","_ErrorFromName","_Events","_Trace","_","completed","promise","targetState","then","state_waiting","state_success_notify","_setState","createErrorDetails","exception","parent","detailsForHandledError","errorValue","context","_isException","errorId","_errorId","detailsForChainedError","setErrorInfo","detailsForError","error_number","detailsForException","exceptionValue","onComplete","onProgress","pushListener","p","asyncOpID","onerrorDetails","callonerror","state_error_notify","notifySuccess","MS_ASYNC_OP_STATUS_SUCCESS","_setCompleteValue","ex","_setExceptionValue","_state","CompletePromise","notifyError","errorID","canceledName","MS_ASYNC_OP_STATUS_CANCELED","MS_ASYNC_OP_STATUS_ERROR","asyncCallbackStarted","handlesOnError","_setChainedErrorValue","ErrorPromise","onerrorDetailsGenerator","promiseEventListeners","errorET","progress","_progress","isException","setErrorValue","state_error","setCompleteValue","state_success","ThenPromise","setNonUserCodeExceptions","tagWithStack","tag","thenPromise","errorPromise","exceptionPromise","completePromise","all","state_created","state_working","state_waiting_canceled","state_canceled","state_canceling","enter","cancel","_completed","_error","_notify","_setErrorValue","waitedUpon","_chainedError","_cancelAction","_cleanupAction","staticCanceledPromise","PromiseStateMachine","_nextState","_run","creator","_stack","Promise","_getStack","_creator","unused","_doneHandler","ExceptionPromise","newValue","oncancel","_oncancel","eventType","capture","any","canceled","as","is","errors","undefineds","pending","argDone","errorCount","canceledCount","Key","Done","thenEach","time","timeoutMS","clearTimeout","cancelTimeout","timeoutWithPromise","wrapError","_veryExpensiveTagWithStack","_veryExpensiveTagWithStack_tag","debuggerEnabled","_cancelBlocker","input","output","_StateMachine","TPromise","PPromise","onUnexpectedError","isPromiseCanceledError","errorHandler","outstandingPromiseErrors","winjs_base_1","log","ErrorHandler","unexpectedErrorHandler","addListener","_removeListener","emit","setUnexpectedErrorHandler","newUnexpectedErrorHandler","getUnexpectedErrorHandler","onUnexpectedExternalError","transformErrorForSerialization","$isError","stacktrace","illegalArgument","illegalState","readonly","disposed","isErrorWithActions","actions","getErrorMessage","event","thisArgs","mapEvent","each","filterEvent","filter","latch","firstCall","shouldEmit","Event","_disposable","Emitter","_options","_event","linkedList_1","firstListener","onFirstListenerAdd","onFirstListenerDidAdd","onListenerDidAdd","_noop","_disposed","onLastListenerRemove","fire","_deliveryQueue","event_1","errors_1","EventMultiplexer","hasListeners","events","emitter","add","hook","lifecycle_1","unhook","fromCallback","fromPromise","toPromise","sub","anyEvent","debounceEvent","merger","delay","leading","subscription","handle","numDebouncedCalls","cur","_output","EventBufferer","buffers","wrapEvent","buffer","bufferEvents","flush","ChainableEvent","on","chain","stopwatch","getTime","echo","Relay","disposable","fromNodeEventEmitter","eventName","removeListener","CancellationToken","shortcutEvent","isCancellationRequested","onCancellationRequested","Cancelled","MutableToken","_isCancelled","_emitter","CancellationTokenSource","_token","isThenable","always","winjsPromiseOrThenable","isWinJSPromise","e1","sequence","promiseFactories","thenHandler","toThenable","asWinJsPromise","cancellation_1","reject","token","wireCancellationToken","resolveAsUndefinedWhenCancelled","Throttler","activePromise","queuedPromise","queuedPromiseFactory","promiseFactory","onComplete_1","SimpleThrottler","promiseTask","Delayer","defaultDelay","completionPromise","onSuccess","task","trigger","isTriggered","ThrottledDelayer","throttler","Barrier","_isOpen","_promise","_completePromise","isOpen","open","wait","ShallowCancelThenPromise","outer","completeCallback","errorCallback","progressCallback","shouldStop","loop","Limiter","maxDegreeOfParalellism","outstandingPromises","runningPromises","_onFinished","consume","iLimitedTask","consumed","Queue","ResourceQueue","queues","queueFor","queue_1","onFinished","setDisposableTimeout","TimeoutTimer","cancelAndSet","runner","setIfNotSet","IntervalTimer","clearInterval","interval","setInterval","RunOnceScheduler","timeoutToken","timeoutHandler","onTimeout","isScheduled","schedule","nfcall","ninvoke","ThrottledEmitter","throttle","suspended","resume","lastEvent","hasLastEvent","INITIALIZE","webWorkerWarningLogged","logOnceWebWorkerWarning","platform_1","SimpleWorkerProtocol","_workerId","_handler","_lastSentReq","_pendingReplies","setWorkerId","workerId","sendMessage","method","req","reply","_send","vsWorker","handleMessage","serializedMessage","_handleMessage","msg","seq","replyMessage","requestMessage","strMsg","stringify","SimpleWorkerClient","workerFactory","lazyProxyFulfill","lazyProxyReject","_worker","_protocol","postMessage","getId","loaderConfiguration","requirejs","contexts","_lazyProxy","_onModuleLoaded","availableMethods","proxy","createProxyMethod","proxyMethodRequest","_onError","_request","getProxyObject","async_1","info","SimpleWorkerServer","postSerializedMessage","requestHandler","_requestHandler","onmessage","initialize","loaderConfig","methods","prop","vs","cc","ee","handlerModule","Position","lineNumber","column","isBefore","isBeforeOrEqual","aLineNumber","bLineNumber","clone","lift","isIPosition","Range","startLineNumber","startColumn","endLineNumber","endColumn","range","containsPosition","position","containsRange","otherRange","plusRange","intersectRanges","resultStartLineNumber","resultStartColumn","resultEndLineNumber","resultEndColumn","otherStartLineNumber","otherStartColumn","otherEndLineNumber","otherEndColumn","equalsRange","getEndPosition","position_1","getStartPosition","setEndPosition","setStartPosition","collapseToStart","fromPositions","isIRange","areIntersectingOrTouching","compareRangesUsingStarts","aStartLineNumber","bStartLineNumber","aStartColumn","bStartColumn","aEndLineNumber","bEndLineNumber","compareRangesUsingEnds","spansMultipleLines","SelectionDirection","Selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","equalsSelection","selectionsEqual","getDirection","LTR","RTL","getPosition","liftSelection","sel","selectionsArrEqual","isISelection","createWithDirection","direction","range_1","Token","TokenizationResult","tokens","endState","TokenizationResult2","toUint32","Uint8Matrix","rows","cols","defaultValue","Uint8Array","_data","row","Constants","toUint8","toUint32Array","arr","Uint32Array","CharacterClassifier","_defaultValue","uint_1","_asciiMap","_createAsciiMap","asciiMap","Boolean","CharacterSet","_actual","computeDiff","modifiedSequence","diff_1","MAXIMUM_RUN_TIME","MINIMUM_MATCHING_CHARACTER_LENGTH","MarkerSequence","startMarkers","endMarkers","getStartLineNumber","getStartColumn","getEndLineNumber","getEndColumn","LineMarkerSequence","lines","length_1","_getFirstNonBlankColumn","_getLastNonBlankColumn","txt","strings","getCharSequence","endIndex","startMarker","endMarker","CharChange","originalStartLineNumber","originalStartColumn","originalEndLineNumber","originalEndColumn","modifiedStartLineNumber","modifiedStartColumn","modifiedEndLineNumber","modifiedEndColumn","createFromDiffChange","diffChange","originalCharSequence","modifiedCharSequence","LineChange","charChanges","createFromDiffResult","originalLineSequence","modifiedLineSequence","shouldPostProcessCharChanges","rawChanges","currChange","originalMatchingLength","modifiedMatchingLength","postProcessCharChanges","length_2","DiffComputer","originalLines","modifiedLines","shouldIgnoreTrimWhitespace","shouldMakePrettyDiff","maximumRunTimeMs","computationStartTime","_continueProcessingPredicate","lineChanges","length_3","originalLineIndex","modifiedLineIndex","nextChange","originalLine","modifiedLine","originalChar","modifiedChar","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","USUAL_WORD_SEPARATORS","DEFAULT_WORD_REGEXP","allowInWords","createWordRegExp","ensureValidWordDefinition","wordDefinition","flags","getWordAtText","textOffset","word","getWordAtPosSlow","getWordAtPosFast","State","CharacterClass","StateMachine","edges","maxCharCode","maxState","states","_b","_states","_maxCharCode","nextState","currentState","_stateMachine","_classifier","LinkComputer","_createLink","classifier","linkBeginIndex","linkEndIndex","lastIncludedCharIndex","charCodeBeforeLink","lastCharCodeInLink","computeLinks","model","stateMachine","characterClassifier_1","getClassifier","lineCount","getLineCount","getLineContent","linkBeginChCode","hasOpenParens","hasOpenSquareBracket","hasOpenCurlyBracket","resetStateMachine","chClass","BasicInplaceReplace","_defaultValueSet","navigateValueSet","range1","text1","range2","text2","up","doNavigateValueSet","numberResult","numberReplace","textReplace","precision","pow","n1","n2","parseFloat","floor","valueSetsReplace","valueSets","valueSetReplace","valueSet","Severity","MarkerSeverity","chord","keyCodes_1","CtrlCmd","Shift","Alt","WinCtrl","createMonacoBaseAPI","editor","languages","selection_1","Uri","token_1","PrefixSumIndexOfResult","remainder","PrefixSumComputer","prefixSum","prefixSumValidIndex","Int32Array","getCount","insertValues","insertIndex","oldValues","oldPrefixSum","insertValuesLen","subarray","changeValue","removeValues","cnt","maxCnt","getTotalValue","_getAccumulatedValue","getAccumulatedValue","getIndexOf","accumulatedValue","midStop","midStart","low","high","PrefixSumComputerWithCache","_cacheAccumulatedValueStart","_bustCache","cacheIndex","warmUpCache","accumulatedValueStart","accumulatedValueEnd","newCache","MirrorTextModel","eol","versionId","_uri","_lines","_eol","_versionId","getText","onEvents","_lineStarts","_acceptDeleteRange","_acceptInsertText","_ensureLineStarts","eolLength","linesLength","lineStartValues","prefixSumComputer_1","_setLineText","lineIndex","insertText","insertLines","newLengths","MirrorModel","getValue","getLinesContent","getWordAtPosition","wordAtText","wordHelper_1","getWordUntilPosition","wordAtPosition","createWordIterator","lineText","wordRangesIdx","wordRanges","_wordenize","getValueInRange","_validateRange","lineEnding","startLineIndex","endLineIndex","resultLines","offsetAt","_validatePosition","positionAt","out","lineLength","hasChanged","maxCharacter","mirrorTextModel_1","BaseEditorSimpleWorker","foreignModuleFactory","_foreignModuleFactory","_foreignModule","originalUrl","modifiedUrl","ignoreTrimWhitespace","_getModel","diffComputer","diffComputer_1","computeDirtyDiff","computeMoreMinimalEdits","modelUrl","edits","lastEol","edits_1","_diffLimit","editOffset","changes_1","newEdit","linkComputer_1","textualSuggest","wordDef","wordDefFlags","suggestions","wordDefRegExp","currentWord","seen","_suggestionsLimit","label","noAutoAccept","overwriteBefore","selectionText","wordRange","inplaceReplaceSupport_1","loadForeignModule","createData","ctx","getMirrorModels","_getModels","foreignModule","fmr","EditorSimpleWorkerImpl","_models","acceptNewModel","EOL","acceptModelChanged","strURL","acceptRemovedModel","monaco","standaloneBase_1","MonacoEnvironment","monacoBaseUrl","isFirstMessage","beforeReadyMessages","ws","messageHandler","loadCode"],"mappings":"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","file":"workerMain.js","sourcesContent":["}).call(this);","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/*---------------------------------------------------------------------------------------------\n * 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 *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n * Please make sure to make edits in the .ts file at https://github.com/Microsoft/vscode-loader/\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *---------------------------------------------------------------------------------------------\n *--------------------------------------------------------------------------------------------*/\nvar _amdLoaderGlobal = this;\nvar AMDLoader;\n(function (AMDLoader) {\n AMDLoader.global = _amdLoaderGlobal;\n var Environment = /** @class */ (function () {\n function Environment() {\n this._detected = false;\n this._isWindows = false;\n this._isNode = false;\n this._isElectronRenderer = false;\n this._isWebWorker = false;\n }\n Object.defineProperty(Environment.prototype, \"isWindows\", {\n get: function () {\n this._detect();\n return this._isWindows;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"isNode\", {\n get: function () {\n this._detect();\n return this._isNode;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"isElectronRenderer\", {\n get: function () {\n this._detect();\n return this._isElectronRenderer;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"isWebWorker\", {\n get: function () {\n this._detect();\n return this._isWebWorker;\n },\n enumerable: true,\n configurable: true\n });\n Environment.prototype._detect = function () {\n if (this._detected) {\n return;\n }\n this._detected = true;\n this._isWindows = Environment._isWindows();\n this._isNode = (typeof module !== 'undefined' && !!module.exports);\n this._isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');\n this._isWebWorker = (typeof AMDLoader.global.importScripts === 'function');\n };\n Environment._isWindows = function () {\n if (typeof navigator !== 'undefined') {\n if (navigator.userAgent && navigator.userAgent.indexOf('Windows') >= 0) {\n return true;\n }\n }\n if (typeof process !== 'undefined') {\n return (process.platform === 'win32');\n }\n return false;\n };\n return Environment;\n }());\n AMDLoader.Environment = Environment;\n})(AMDLoader || (AMDLoader = {}));\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 AMDLoader;\n(function (AMDLoader) {\n var LoaderEvent = /** @class */ (function () {\n function LoaderEvent(type, detail, timestamp) {\n this.type = type;\n this.detail = detail;\n this.timestamp = timestamp;\n }\n return LoaderEvent;\n }());\n AMDLoader.LoaderEvent = LoaderEvent;\n var LoaderEventRecorder = /** @class */ (function () {\n function LoaderEventRecorder(loaderAvailableTimestamp) {\n this._events = [new LoaderEvent(1 /* LoaderAvailable */, '', loaderAvailableTimestamp)];\n }\n LoaderEventRecorder.prototype.record = function (type, detail) {\n this._events.push(new LoaderEvent(type, detail, AMDLoader.Utilities.getHighPerformanceTimestamp()));\n };\n LoaderEventRecorder.prototype.getEvents = function () {\n return this._events;\n };\n return LoaderEventRecorder;\n }());\n AMDLoader.LoaderEventRecorder = LoaderEventRecorder;\n var NullLoaderEventRecorder = /** @class */ (function () {\n function NullLoaderEventRecorder() {\n }\n NullLoaderEventRecorder.prototype.record = function (type, detail) {\n // Nothing to do\n };\n NullLoaderEventRecorder.prototype.getEvents = function () {\n return [];\n };\n NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();\n return NullLoaderEventRecorder;\n }());\n AMDLoader.NullLoaderEventRecorder = NullLoaderEventRecorder;\n})(AMDLoader || (AMDLoader = {}));\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 AMDLoader;\n(function (AMDLoader) {\n var Utilities = /** @class */ (function () {\n function Utilities() {\n }\n /**\n * This method does not take care of / vs \\\n */\n Utilities.fileUriToFilePath = function (isWindows, uri) {\n uri = decodeURI(uri);\n if (isWindows) {\n if (/^file:\\/\\/\\//.test(uri)) {\n // This is a URI without a hostname => return only the path segment\n return uri.substr(8);\n }\n if (/^file:\\/\\//.test(uri)) {\n return uri.substr(5);\n }\n }\n else {\n if (/^file:\\/\\//.test(uri)) {\n return uri.substr(7);\n }\n }\n // Not sure...\n return uri;\n };\n Utilities.startsWith = function (haystack, needle) {\n return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;\n };\n Utilities.endsWith = function (haystack, needle) {\n return haystack.length >= needle.length && haystack.substr(haystack.length - needle.length) === needle;\n };\n // only check for \"?\" before \"#\" to ensure that there is a real Query-String\n Utilities.containsQueryString = function (url) {\n return /^[^\\#]*\\?/gi.test(url);\n };\n /**\n * Does `url` start with http:// or https:// or file:// or / ?\n */\n Utilities.isAbsolutePath = function (url) {\n return /^((http:\\/\\/)|(https:\\/\\/)|(file:\\/\\/)|(\\/))/.test(url);\n };\n Utilities.forEachProperty = function (obj, callback) {\n if (obj) {\n var key = void 0;\n for (key in obj) {\n if (obj.hasOwnProperty(key)) {\n callback(key, obj[key]);\n }\n }\n }\n };\n Utilities.isEmpty = function (obj) {\n var isEmpty = true;\n Utilities.forEachProperty(obj, function () {\n isEmpty = false;\n });\n return isEmpty;\n };\n Utilities.recursiveClone = function (obj) {\n if (!obj || typeof obj !== 'object') {\n return obj;\n }\n var result = Array.isArray(obj) ? [] : {};\n Utilities.forEachProperty(obj, function (key, value) {\n if (value && typeof value === 'object') {\n result[key] = Utilities.recursiveClone(value);\n }\n else {\n result[key] = value;\n }\n });\n return result;\n };\n Utilities.generateAnonymousModule = function () {\n return '===anonymous' + (Utilities.NEXT_ANONYMOUS_ID++) + '===';\n };\n Utilities.isAnonymousModule = function (id) {\n return /^===anonymous/.test(id);\n };\n Utilities.getHighPerformanceTimestamp = function () {\n if (!this.PERFORMANCE_NOW_PROBED) {\n this.PERFORMANCE_NOW_PROBED = true;\n this.HAS_PERFORMANCE_NOW = (AMDLoader.global.performance && typeof AMDLoader.global.performance.now === 'function');\n }\n return (this.HAS_PERFORMANCE_NOW ? AMDLoader.global.performance.now() : Date.now());\n };\n Utilities.NEXT_ANONYMOUS_ID = 1;\n Utilities.PERFORMANCE_NOW_PROBED = false;\n Utilities.HAS_PERFORMANCE_NOW = false;\n return Utilities;\n }());\n AMDLoader.Utilities = Utilities;\n})(AMDLoader || (AMDLoader = {}));\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 AMDLoader;\n(function (AMDLoader) {\n var ConfigurationOptionsUtil = /** @class */ (function () {\n function ConfigurationOptionsUtil() {\n }\n /**\n * Ensure configuration options make sense\n */\n ConfigurationOptionsUtil.validateConfigurationOptions = function (options) {\n function defaultOnError(err) {\n if (err.errorCode === 'load') {\n console.error('Loading \"' + err.moduleId + '\" failed');\n console.error('Detail: ', err.detail);\n if (err.detail && err.detail.stack) {\n console.error(err.detail.stack);\n }\n console.error('Here are the modules that depend on it:');\n console.error(err.neededBy);\n return;\n }\n if (err.errorCode === 'factory') {\n console.error('The factory method of \"' + err.moduleId + '\" has thrown an exception');\n console.error(err.detail);\n if (err.detail && err.detail.stack) {\n console.error(err.detail.stack);\n }\n return;\n }\n }\n options = options || {};\n if (typeof options.baseUrl !== 'string') {\n options.baseUrl = '';\n }\n if (typeof options.isBuild !== 'boolean') {\n options.isBuild = false;\n }\n if (typeof options.paths !== 'object') {\n options.paths = {};\n }\n if (typeof options.config !== 'object') {\n options.config = {};\n }\n if (typeof options.catchError === 'undefined') {\n options.catchError = false;\n }\n if (typeof options.urlArgs !== 'string') {\n options.urlArgs = '';\n }\n if (typeof options.onError !== 'function') {\n options.onError = defaultOnError;\n }\n if (typeof options.ignoreDuplicateModules !== 'object' || !Array.isArray(options.ignoreDuplicateModules)) {\n options.ignoreDuplicateModules = [];\n }\n if (options.baseUrl.length > 0) {\n if (!AMDLoader.Utilities.endsWith(options.baseUrl, '/')) {\n options.baseUrl += '/';\n }\n }\n if (!Array.isArray(options.nodeModules)) {\n options.nodeModules = [];\n }\n if (typeof options.nodeCachedDataWriteDelay !== 'number' || options.nodeCachedDataWriteDelay < 0) {\n options.nodeCachedDataWriteDelay = 1000 * 7;\n }\n if (typeof options.onNodeCachedData !== 'function') {\n options.onNodeCachedData = function (err, data) {\n if (!err) {\n // ignore\n }\n else if (err.errorCode === 'cachedDataRejected') {\n console.warn('Rejected cached data from file: ' + err.path);\n }\n else if (err.errorCode === 'unlink' || err.errorCode === 'writeFile') {\n console.error('Problems writing cached data file: ' + err.path);\n console.error(err.detail);\n }\n else {\n console.error(err);\n }\n };\n }\n return options;\n };\n ConfigurationOptionsUtil.mergeConfigurationOptions = function (overwrite, base) {\n if (overwrite === void 0) { overwrite = null; }\n if (base === void 0) { base = null; }\n var result = AMDLoader.Utilities.recursiveClone(base || {});\n // Merge known properties and overwrite the unknown ones\n AMDLoader.Utilities.forEachProperty(overwrite, function (key, value) {\n if (key === 'ignoreDuplicateModules' && typeof result.ignoreDuplicateModules !== 'undefined') {\n result.ignoreDuplicateModules = result.ignoreDuplicateModules.concat(value);\n }\n else if (key === 'paths' && typeof result.paths !== 'undefined') {\n AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.paths[key2] = value2; });\n }\n else if (key === 'config' && typeof result.config !== 'undefined') {\n AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.config[key2] = value2; });\n }\n else {\n result[key] = AMDLoader.Utilities.recursiveClone(value);\n }\n });\n return ConfigurationOptionsUtil.validateConfigurationOptions(result);\n };\n return ConfigurationOptionsUtil;\n }());\n AMDLoader.ConfigurationOptionsUtil = ConfigurationOptionsUtil;\n var Configuration = /** @class */ (function () {\n function Configuration(env, options) {\n this._env = env;\n this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);\n this._createIgnoreDuplicateModulesMap();\n this._createNodeModulesMap();\n this._createSortedPathsRules();\n if (this.options.baseUrl === '') {\n if (this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename && this._env.isNode) {\n var nodeMain = this.options.nodeRequire.main.filename;\n var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\\\'));\n this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);\n }\n if (this.options.nodeMain && this._env.isNode) {\n var nodeMain = this.options.nodeMain;\n var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\\\'));\n this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);\n }\n }\n }\n Configuration.prototype._createIgnoreDuplicateModulesMap = function () {\n // Build a map out of the ignoreDuplicateModules array\n this.ignoreDuplicateModulesMap = {};\n for (var i = 0; i < this.options.ignoreDuplicateModules.length; i++) {\n this.ignoreDuplicateModulesMap[this.options.ignoreDuplicateModules[i]] = true;\n }\n };\n Configuration.prototype._createNodeModulesMap = function () {\n // Build a map out of nodeModules array\n this.nodeModulesMap = Object.create(null);\n for (var _i = 0, _a = this.options.nodeModules; _i < _a.length; _i++) {\n var nodeModule = _a[_i];\n this.nodeModulesMap[nodeModule] = true;\n }\n };\n Configuration.prototype._createSortedPathsRules = function () {\n var _this = this;\n // Create an array our of the paths rules, sorted descending by length to\n // result in a more specific -> less specific order\n this.sortedPathsRules = [];\n AMDLoader.Utilities.forEachProperty(this.options.paths, function (from, to) {\n if (!Array.isArray(to)) {\n _this.sortedPathsRules.push({\n from: from,\n to: [to]\n });\n }\n else {\n _this.sortedPathsRules.push({\n from: from,\n to: to\n });\n }\n });\n this.sortedPathsRules.sort(function (a, b) {\n return b.from.length - a.from.length;\n });\n };\n /**\n * Clone current configuration and overwrite options selectively.\n * @param options The selective options to overwrite with.\n * @result A new configuration\n */\n Configuration.prototype.cloneAndMerge = function (options) {\n return new Configuration(this._env, ConfigurationOptionsUtil.mergeConfigurationOptions(options, this.options));\n };\n /**\n * Get current options bag. Useful for passing it forward to plugins.\n */\n Configuration.prototype.getOptionsLiteral = function () {\n return this.options;\n };\n Configuration.prototype._applyPaths = function (moduleId) {\n var pathRule;\n for (var i = 0, len = this.sortedPathsRules.length; i < len; i++) {\n pathRule = this.sortedPathsRules[i];\n if (AMDLoader.Utilities.startsWith(moduleId, pathRule.from)) {\n var result = [];\n for (var j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {\n result.push(pathRule.to[j] + moduleId.substr(pathRule.from.length));\n }\n return result;\n }\n }\n return [moduleId];\n };\n Configuration.prototype._addUrlArgsToUrl = function (url) {\n if (AMDLoader.Utilities.containsQueryString(url)) {\n return url + '&' + this.options.urlArgs;\n }\n else {\n return url + '?' + this.options.urlArgs;\n }\n };\n Configuration.prototype._addUrlArgsIfNecessaryToUrl = function (url) {\n if (this.options.urlArgs) {\n return this._addUrlArgsToUrl(url);\n }\n return url;\n };\n Configuration.prototype._addUrlArgsIfNecessaryToUrls = function (urls) {\n if (this.options.urlArgs) {\n for (var i = 0, len = urls.length; i < len; i++) {\n urls[i] = this._addUrlArgsToUrl(urls[i]);\n }\n }\n return urls;\n };\n /**\n * Transform a module id to a location. Appends .js to module ids\n */\n Configuration.prototype.moduleIdToPaths = function (moduleId) {\n if (this.nodeModulesMap[moduleId] === true) {\n // This is a node module...\n if (this.isBuild()) {\n // ...and we are at build time, drop it\n return ['empty:'];\n }\n else {\n // ...and at runtime we create a `shortcut`-path\n return ['node|' + moduleId];\n }\n }\n var result = moduleId;\n var results;\n if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.isAbsolutePath(result)) {\n results = this._applyPaths(result);\n for (var i = 0, len = results.length; i < len; i++) {\n if (this.isBuild() && results[i] === 'empty:') {\n continue;\n }\n if (!AMDLoader.Utilities.isAbsolutePath(results[i])) {\n results[i] = this.options.baseUrl + results[i];\n }\n if (!AMDLoader.Utilities.endsWith(results[i], '.js') && !AMDLoader.Utilities.containsQueryString(results[i])) {\n results[i] = results[i] + '.js';\n }\n }\n }\n else {\n if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.containsQueryString(result)) {\n result = result + '.js';\n }\n results = [result];\n }\n return this._addUrlArgsIfNecessaryToUrls(results);\n };\n /**\n * Transform a module id or url to a location.\n */\n Configuration.prototype.requireToUrl = function (url) {\n var result = url;\n if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n result = this._applyPaths(result)[0];\n if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n result = this.options.baseUrl + result;\n }\n }\n return this._addUrlArgsIfNecessaryToUrl(result);\n };\n /**\n * Flag to indicate if current execution is as part of a build.\n */\n Configuration.prototype.isBuild = function () {\n return this.options.isBuild;\n };\n /**\n * Test if module `moduleId` is expected to be defined multiple times\n */\n Configuration.prototype.isDuplicateMessageIgnoredFor = function (moduleId) {\n return this.ignoreDuplicateModulesMap.hasOwnProperty(moduleId);\n };\n /**\n * Get the configuration settings for the provided module id\n */\n Configuration.prototype.getConfigForModule = function (moduleId) {\n if (this.options.config) {\n return this.options.config[moduleId];\n }\n };\n /**\n * Should errors be caught when executing module factories?\n */\n Configuration.prototype.shouldCatchError = function () {\n return this.options.catchError;\n };\n /**\n * Should statistics be recorded?\n */\n Configuration.prototype.shouldRecordStats = function () {\n return this.options.recordStats;\n };\n /**\n * Forward an error to the error handler.\n */\n Configuration.prototype.onError = function (err) {\n this.options.onError(err);\n };\n return Configuration;\n }());\n AMDLoader.Configuration = Configuration;\n})(AMDLoader || (AMDLoader = {}));\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 AMDLoader;\n(function (AMDLoader) {\n /**\n * Load `scriptSrc` only once (avoid multiple <script> tags)\n */\n var OnlyOnceScriptLoader = /** @class */ (function () {\n function OnlyOnceScriptLoader(env) {\n this._env = env;\n this._scriptLoader = null;\n this._callbackMap = {};\n }\n OnlyOnceScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n var _this = this;\n if (!this._scriptLoader) {\n this._scriptLoader = (this._env.isWebWorker\n ? new WorkerScriptLoader()\n : this._env.isNode\n ? new NodeScriptLoader(this._env)\n : new BrowserScriptLoader());\n }\n var scriptCallbacks = {\n callback: callback,\n errorback: errorback\n };\n if (this._callbackMap.hasOwnProperty(scriptSrc)) {\n this._callbackMap[scriptSrc].push(scriptCallbacks);\n return;\n }\n this._callbackMap[scriptSrc] = [scriptCallbacks];\n this._scriptLoader.load(moduleManager, scriptSrc, function () { return _this.triggerCallback(scriptSrc); }, function (err) { return _this.triggerErrorback(scriptSrc, err); });\n };\n OnlyOnceScriptLoader.prototype.triggerCallback = function (scriptSrc) {\n var scriptCallbacks = this._callbackMap[scriptSrc];\n delete this._callbackMap[scriptSrc];\n for (var i = 0; i < scriptCallbacks.length; i++) {\n scriptCallbacks[i].callback();\n }\n };\n OnlyOnceScriptLoader.prototype.triggerErrorback = function (scriptSrc, err) {\n var scriptCallbacks = this._callbackMap[scriptSrc];\n delete this._callbackMap[scriptSrc];\n for (var i = 0; i < scriptCallbacks.length; i++) {\n scriptCallbacks[i].errorback(err);\n }\n };\n return OnlyOnceScriptLoader;\n }());\n var BrowserScriptLoader = /** @class */ (function () {\n function BrowserScriptLoader() {\n }\n /**\n * Attach load / error listeners to a script element and remove them when either one has fired.\n * Implemented for browssers supporting HTML5 standard 'load' and 'error' events.\n */\n BrowserScriptLoader.prototype.attachListeners = function (script, callback, errorback) {\n var unbind = function () {\n script.removeEventListener('load', loadEventListener);\n script.removeEventListener('error', errorEventListener);\n };\n var loadEventListener = function (e) {\n unbind();\n callback();\n };\n var errorEventListener = function (e) {\n unbind();\n errorback(e);\n };\n script.addEventListener('load', loadEventListener);\n script.addEventListener('error', errorEventListener);\n };\n BrowserScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n var script = document.createElement('script');\n script.setAttribute('async', 'async');\n script.setAttribute('type', 'text/javascript');\n this.attachListeners(script, callback, errorback);\n script.setAttribute('src', scriptSrc);\n document.getElementsByTagName('head')[0].appendChild(script);\n };\n return BrowserScriptLoader;\n }());\n var WorkerScriptLoader = /** @class */ (function () {\n function WorkerScriptLoader() {\n }\n WorkerScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n try {\n importScripts(scriptSrc);\n callback();\n }\n catch (e) {\n errorback(e);\n }\n };\n return WorkerScriptLoader;\n }());\n var NodeScriptLoader = /** @class */ (function () {\n function NodeScriptLoader(env) {\n this._env = env;\n this._didInitialize = false;\n this._didPatchNodeRequire = false;\n }\n NodeScriptLoader.prototype._init = function (nodeRequire) {\n if (this._didInitialize) {\n return;\n }\n this._didInitialize = true;\n // capture node modules\n this._fs = nodeRequire('fs');\n this._vm = nodeRequire('vm');\n this._path = nodeRequire('path');\n this._crypto = nodeRequire('crypto');\n // js-flags have an impact on cached data\n this._jsflags = '';\n for (var _i = 0, _a = process.argv; _i < _a.length; _i++) {\n var arg = _a[_i];\n if (arg.indexOf('--js-flags=') === 0) {\n this._jsflags = arg;\n break;\n }\n }\n };\n // patch require-function of nodejs such that we can manually create a script\n // from cached data. this is done by overriding the `Module._compile` function\n NodeScriptLoader.prototype._initNodeRequire = function (nodeRequire, moduleManager) {\n var nodeCachedDataDir = moduleManager.getConfig().getOptionsLiteral().nodeCachedDataDir;\n if (!nodeCachedDataDir || this._didPatchNodeRequire) {\n return;\n }\n this._didPatchNodeRequire = true;\n var that = this;\n var Module = nodeRequire('module');\n function makeRequireFunction(mod) {\n var Module = mod.constructor;\n var require = function require(path) {\n try {\n return mod.require(path);\n }\n finally {\n // nothing\n }\n };\n require.resolve = function resolve(request) {\n return Module._resolveFilename(request, mod);\n };\n require.main = process.mainModule;\n require.extensions = Module._extensions;\n require.cache = Module._cache;\n return require;\n }\n Module.prototype._compile = function (content, filename) {\n // remove shebang\n content = content.replace(/^#!.*/, '');\n // create wrapper function\n var wrapper = Module.wrap(content);\n var cachedDataPath = that._getCachedDataPath(nodeCachedDataDir, filename);\n var options = { filename: filename };\n try {\n options.cachedData = that._fs.readFileSync(cachedDataPath);\n }\n catch (e) {\n options.produceCachedData = true;\n }\n var script = new that._vm.Script(wrapper, options);\n var compileWrapper = script.runInThisContext(options);\n var dirname = that._path.dirname(filename);\n var require = makeRequireFunction(this);\n var args = [this.exports, require, this, filename, dirname, process, AMDLoader.global, Buffer];\n var result = compileWrapper.apply(this.exports, args);\n that._processCachedData(moduleManager, script, cachedDataPath);\n return result;\n };\n };\n NodeScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {\n var _this = this;\n var opts = moduleManager.getConfig().getOptionsLiteral();\n var nodeRequire = (opts.nodeRequire || AMDLoader.global.nodeRequire);\n var nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });\n this._init(nodeRequire);\n this._initNodeRequire(nodeRequire, moduleManager);\n var recorder = moduleManager.getRecorder();\n if (/^node\\|/.test(scriptSrc)) {\n var pieces = scriptSrc.split('|');\n var moduleExports_1 = null;\n try {\n moduleExports_1 = nodeRequire(pieces[1]);\n }\n catch (err) {\n errorback(err);\n return;\n }\n moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_1; });\n callback();\n }\n else {\n scriptSrc = AMDLoader.Utilities.fileUriToFilePath(this._env.isWindows, scriptSrc);\n this._fs.readFile(scriptSrc, { encoding: 'utf8' }, function (err, data) {\n if (err) {\n errorback(err);\n return;\n }\n var normalizedScriptSrc = _this._path.normalize(scriptSrc);\n var vmScriptSrc = normalizedScriptSrc;\n // Make the script src friendly towards electron\n if (_this._env.isElectronRenderer) {\n var driveLetterMatch = vmScriptSrc.match(/^([a-z])\\:(.*)/i);\n if (driveLetterMatch) {\n // windows\n vmScriptSrc = \"file:///\" + (driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\\\/g, '/');\n }\n else {\n // nix\n vmScriptSrc = \"file://\" + vmScriptSrc;\n }\n }\n var contents, prefix = '(function (require, define, __filename, __dirname) { ', suffix = '\\n});';\n if (data.charCodeAt(0) === NodeScriptLoader._BOM) {\n contents = prefix + data.substring(1) + suffix;\n }\n else {\n contents = prefix + data + suffix;\n }\n contents = nodeInstrumenter(contents, normalizedScriptSrc);\n if (!opts.nodeCachedDataDir) {\n _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, { filename: vmScriptSrc }, recorder);\n callback();\n }\n else {\n var cachedDataPath_1 = _this._getCachedDataPath(opts.nodeCachedDataDir, scriptSrc);\n _this._fs.readFile(cachedDataPath_1, function (err, cachedData) {\n // create script options\n var options = {\n filename: vmScriptSrc,\n produceCachedData: typeof cachedData === 'undefined',\n cachedData: cachedData\n };\n var script = _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder);\n callback();\n _this._processCachedData(moduleManager, script, cachedDataPath_1);\n });\n }\n });\n }\n };\n NodeScriptLoader.prototype._loadAndEvalScript = function (moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder) {\n // create script, run script\n recorder.record(31 /* NodeBeginEvaluatingScript */, scriptSrc);\n var script = new this._vm.Script(contents, options);\n var r = script.runInThisContext(options);\n r.call(AMDLoader.global, moduleManager.getGlobalAMDRequireFunc(), moduleManager.getGlobalAMDDefineFunc(), vmScriptSrc, this._path.dirname(scriptSrc));\n // signal done\n recorder.record(32 /* NodeEndEvaluatingScript */, scriptSrc);\n return script;\n };\n NodeScriptLoader.prototype._getCachedDataPath = function (basedir, filename) {\n var hash = this._crypto.createHash('md5').update(filename, 'utf8').update(this._jsflags, 'utf8').digest('hex');\n var basename = this._path.basename(filename).replace(/\\.js$/, '');\n return this._path.join(basedir, basename + \"-\" + hash + \".code\");\n };\n NodeScriptLoader.prototype._processCachedData = function (moduleManager, script, cachedDataPath) {\n var _this = this;\n if (script.cachedDataRejected) {\n // data rejected => delete cache file\n moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({\n errorCode: 'cachedDataRejected',\n path: cachedDataPath\n });\n NodeScriptLoader._runSoon(function () { return _this._fs.unlink(cachedDataPath, function (err) {\n if (err) {\n moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({\n errorCode: 'unlink',\n path: cachedDataPath,\n detail: err\n });\n }\n }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);\n }\n else if (script.cachedDataProduced) {\n // data produced => tell outside world\n moduleManager.getConfig().getOptionsLiteral().onNodeCachedData(undefined, {\n path: cachedDataPath,\n length: script.cachedData.length\n });\n // data produced => write cache file\n NodeScriptLoader._runSoon(function () { return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {\n if (err) {\n moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({\n errorCode: 'writeFile',\n path: cachedDataPath,\n detail: err\n });\n }\n }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);\n }\n };\n NodeScriptLoader._runSoon = function (callback, minTimeout) {\n var timeout = minTimeout + Math.ceil(Math.random() * minTimeout);\n setTimeout(callback, timeout);\n };\n NodeScriptLoader._BOM = 0xFEFF;\n return NodeScriptLoader;\n }());\n function createScriptLoader(env) {\n return new OnlyOnceScriptLoader(env);\n }\n AMDLoader.createScriptLoader = createScriptLoader;\n})(AMDLoader || (AMDLoader = {}));\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 AMDLoader;\n(function (AMDLoader) {\n // ------------------------------------------------------------------------\n // ModuleIdResolver\n var ModuleIdResolver = /** @class */ (function () {\n function ModuleIdResolver(fromModuleId) {\n var lastSlash = fromModuleId.lastIndexOf('/');\n if (lastSlash !== -1) {\n this.fromModulePath = fromModuleId.substr(0, lastSlash + 1);\n }\n else {\n this.fromModulePath = '';\n }\n }\n /**\n * Normalize 'a/../name' to 'name', etc.\n */\n ModuleIdResolver._normalizeModuleId = function (moduleId) {\n var r = moduleId, pattern;\n // replace /./ => /\n pattern = /\\/\\.\\//;\n while (pattern.test(r)) {\n r = r.replace(pattern, '/');\n }\n // replace ^./ => nothing\n r = r.replace(/^\\.\\//g, '');\n // replace /aa/../ => / (BUT IGNORE /../../)\n pattern = /\\/(([^\\/])|([^\\/][^\\/\\.])|([^\\/\\.][^\\/])|([^\\/][^\\/][^\\/]+))\\/\\.\\.\\//;\n while (pattern.test(r)) {\n r = r.replace(pattern, '/');\n }\n // replace ^aa/../ => nothing (BUT IGNORE ../../)\n r = r.replace(/^(([^\\/])|([^\\/][^\\/\\.])|([^\\/\\.][^\\/])|([^\\/][^\\/][^\\/]+))\\/\\.\\.\\//, '');\n return r;\n };\n /**\n * Resolve relative module ids\n */\n ModuleIdResolver.prototype.resolveModule = function (moduleId) {\n var result = moduleId;\n if (!AMDLoader.Utilities.isAbsolutePath(result)) {\n if (AMDLoader.Utilities.startsWith(result, './') || AMDLoader.Utilities.startsWith(result, '../')) {\n result = ModuleIdResolver._normalizeModuleId(this.fromModulePath + result);\n }\n }\n return result;\n };\n ModuleIdResolver.ROOT = new ModuleIdResolver('');\n return ModuleIdResolver;\n }());\n AMDLoader.ModuleIdResolver = ModuleIdResolver;\n // ------------------------------------------------------------------------\n // Module\n var Module = /** @class */ (function () {\n function Module(id, strId, dependencies, callback, errorback, moduleIdResolver) {\n this.id = id;\n this.strId = strId;\n this.dependencies = dependencies;\n this._callback = callback;\n this._errorback = errorback;\n this.moduleIdResolver = moduleIdResolver;\n this.exports = {};\n this.exportsPassedIn = false;\n this.unresolvedDependenciesCount = this.dependencies.length;\n this._isComplete = false;\n }\n Module._safeInvokeFunction = function (callback, args) {\n try {\n return {\n returnedValue: callback.apply(AMDLoader.global, args),\n producedError: null\n };\n }\n catch (e) {\n return {\n returnedValue: null,\n producedError: e\n };\n }\n };\n Module._invokeFactory = function (config, strModuleId, callback, dependenciesValues) {\n if (config.isBuild() && !AMDLoader.Utilities.isAnonymousModule(strModuleId)) {\n return {\n returnedValue: null,\n producedError: null\n };\n }\n if (config.shouldCatchError()) {\n return this._safeInvokeFunction(callback, dependenciesValues);\n }\n return {\n returnedValue: callback.apply(AMDLoader.global, dependenciesValues),\n producedError: null\n };\n };\n Module.prototype.complete = function (recorder, config, dependenciesValues) {\n this._isComplete = true;\n var producedError = null;\n if (this._callback) {\n if (typeof this._callback === 'function') {\n recorder.record(21 /* BeginInvokeFactory */, this.strId);\n var r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);\n producedError = r.producedError;\n recorder.record(22 /* EndInvokeFactory */, this.strId);\n if (!producedError && typeof r.returnedValue !== 'undefined' && (!this.exportsPassedIn || AMDLoader.Utilities.isEmpty(this.exports))) {\n this.exports = r.returnedValue;\n }\n }\n else {\n this.exports = this._callback;\n }\n }\n if (producedError) {\n config.onError({\n errorCode: 'factory',\n moduleId: this.strId,\n detail: producedError\n });\n }\n this.dependencies = null;\n this._callback = null;\n this._errorback = null;\n this.moduleIdResolver = null;\n };\n /**\n * One of the direct dependencies or a transitive dependency has failed to load.\n */\n Module.prototype.onDependencyError = function (err) {\n if (this._errorback) {\n this._errorback(err);\n return true;\n }\n return false;\n };\n /**\n * Is the current module complete?\n */\n Module.prototype.isComplete = function () {\n return this._isComplete;\n };\n return Module;\n }());\n AMDLoader.Module = Module;\n var ModuleIdProvider = /** @class */ (function () {\n function ModuleIdProvider() {\n this._nextId = 0;\n this._strModuleIdToIntModuleId = new Map();\n this._intModuleIdToStrModuleId = [];\n // Ensure values 0, 1, 2 are assigned accordingly with ModuleId\n this.getModuleId('exports');\n this.getModuleId('module');\n this.getModuleId('require');\n }\n ModuleIdProvider.prototype.getMaxModuleId = function () {\n return this._nextId;\n };\n ModuleIdProvider.prototype.getModuleId = function (strModuleId) {\n var id = this._strModuleIdToIntModuleId.get(strModuleId);\n if (typeof id === 'undefined') {\n id = this._nextId++;\n this._strModuleIdToIntModuleId.set(strModuleId, id);\n this._intModuleIdToStrModuleId[id] = strModuleId;\n }\n return id;\n };\n ModuleIdProvider.prototype.getStrModuleId = function (moduleId) {\n return this._intModuleIdToStrModuleId[moduleId];\n };\n return ModuleIdProvider;\n }());\n var RegularDependency = /** @class */ (function () {\n function RegularDependency(id) {\n this.id = id;\n }\n RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);\n RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);\n RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);\n return RegularDependency;\n }());\n AMDLoader.RegularDependency = RegularDependency;\n var PluginDependency = /** @class */ (function () {\n function PluginDependency(id, pluginId, pluginParam) {\n this.id = id;\n this.pluginId = pluginId;\n this.pluginParam = pluginParam;\n }\n return PluginDependency;\n }());\n AMDLoader.PluginDependency = PluginDependency;\n var ModuleManager = /** @class */ (function () {\n function ModuleManager(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp) {\n if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }\n this._env = env;\n this._scriptLoader = scriptLoader;\n this._loaderAvailableTimestamp = loaderAvailableTimestamp;\n this._defineFunc = defineFunc;\n this._requireFunc = requireFunc;\n this._moduleIdProvider = new ModuleIdProvider();\n this._config = new AMDLoader.Configuration(this._env);\n this._modules2 = [];\n this._knownModules2 = [];\n this._inverseDependencies2 = [];\n this._inversePluginDependencies2 = new Map();\n this._currentAnnonymousDefineCall = null;\n this._recorder = null;\n this._buildInfoPath = [];\n this._buildInfoDefineStack = [];\n this._buildInfoDependencies = [];\n }\n ModuleManager.prototype.reset = function () {\n return new ModuleManager(this._env, this._scriptLoader, this._defineFunc, this._requireFunc, this._loaderAvailableTimestamp);\n };\n ModuleManager.prototype.getGlobalAMDDefineFunc = function () {\n return this._defineFunc;\n };\n ModuleManager.prototype.getGlobalAMDRequireFunc = function () {\n return this._requireFunc;\n };\n ModuleManager._findRelevantLocationInStack = function (needle, stack) {\n var normalize = function (str) { return str.replace(/\\\\/g, '/'); };\n var normalizedPath = normalize(needle);\n var stackPieces = stack.split(/\\n/);\n for (var i = 0; i < stackPieces.length; i++) {\n var m = stackPieces[i].match(/(.*):(\\d+):(\\d+)\\)?$/);\n if (m) {\n var stackPath = m[1];\n var stackLine = m[2];\n var stackColumn = m[3];\n var trimPathOffset = Math.max(stackPath.lastIndexOf(' ') + 1, stackPath.lastIndexOf('(') + 1);\n stackPath = stackPath.substr(trimPathOffset);\n stackPath = normalize(stackPath);\n if (stackPath === normalizedPath) {\n var r = {\n line: parseInt(stackLine, 10),\n col: parseInt(stackColumn, 10)\n };\n if (r.line === 1) {\n r.col -= '(function (require, define, __filename, __dirname) { '.length;\n }\n return r;\n }\n }\n }\n throw new Error('Could not correlate define call site for needle ' + needle);\n };\n ModuleManager.prototype.getBuildInfo = function () {\n if (!this._config.isBuild()) {\n return null;\n }\n var result = [], resultLen = 0;\n for (var i = 0, len = this._modules2.length; i < len; i++) {\n var m = this._modules2[i];\n if (!m) {\n continue;\n }\n var location_1 = this._buildInfoPath[m.id] || null;\n var defineStack = this._buildInfoDefineStack[m.id] || null;\n var dependencies = this._buildInfoDependencies[m.id];\n result[resultLen++] = {\n id: m.strId,\n path: location_1,\n defineLocation: (location_1 && defineStack ? ModuleManager._findRelevantLocationInStack(location_1, defineStack) : null),\n dependencies: dependencies,\n shim: null,\n exports: m.exports\n };\n }\n return result;\n };\n ModuleManager.prototype.getRecorder = function () {\n if (!this._recorder) {\n if (this._config.shouldRecordStats()) {\n this._recorder = new AMDLoader.LoaderEventRecorder(this._loaderAvailableTimestamp);\n }\n else {\n this._recorder = AMDLoader.NullLoaderEventRecorder.INSTANCE;\n }\n }\n return this._recorder;\n };\n ModuleManager.prototype.getLoaderEvents = function () {\n return this.getRecorder().getEvents();\n };\n /**\n * Defines an anonymous module (without an id). Its name will be resolved as we receive a callback from the scriptLoader.\n * @param dependecies @see defineModule\n * @param callback @see defineModule\n */\n ModuleManager.prototype.enqueueDefineAnonymousModule = function (dependencies, callback) {\n if (this._currentAnnonymousDefineCall !== null) {\n throw new Error('Can only have one anonymous define call per script file');\n }\n var stack = null;\n if (this._config.isBuild()) {\n stack = new Error('StackLocation').stack;\n }\n this._currentAnnonymousDefineCall = {\n stack: stack,\n dependencies: dependencies,\n callback: callback\n };\n };\n /**\n * Creates a module and stores it in _modules. The manager will immediately begin resolving its dependencies.\n * @param strModuleId An unique and absolute id of the module. This must not collide with another module's id\n * @param dependencies An array with the dependencies of the module. Special keys are: \"require\", \"exports\" and \"module\"\n * @param callback if callback is a function, it will be called with the resolved dependencies. if callback is an object, it will be considered as the exports of the module.\n */\n ModuleManager.prototype.defineModule = function (strModuleId, dependencies, callback, errorback, stack, moduleIdResolver) {\n var _this = this;\n if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(strModuleId); }\n var moduleId = this._moduleIdProvider.getModuleId(strModuleId);\n if (this._modules2[moduleId]) {\n if (!this._config.isDuplicateMessageIgnoredFor(strModuleId)) {\n console.warn('Duplicate definition of module \\'' + strModuleId + '\\'');\n }\n // Super important! Completely ignore duplicate module definition\n return;\n }\n var m = new Module(moduleId, strModuleId, this._normalizeDependencies(dependencies, moduleIdResolver), callback, errorback, moduleIdResolver);\n this._modules2[moduleId] = m;\n if (this._config.isBuild()) {\n this._buildInfoDefineStack[moduleId] = stack;\n this._buildInfoDependencies[moduleId] = m.dependencies.map(function (dep) { return _this._moduleIdProvider.getStrModuleId(dep.id); });\n }\n // Resolving of dependencies is immediate (not in a timeout). If there's a need to support a packer that concatenates in an\n // unordered manner, in order to finish processing the file, execute the following method in a timeout\n this._resolve(m);\n };\n ModuleManager.prototype._normalizeDependency = function (dependency, moduleIdResolver) {\n if (dependency === 'exports') {\n return RegularDependency.EXPORTS;\n }\n if (dependency === 'module') {\n return RegularDependency.MODULE;\n }\n if (dependency === 'require') {\n return RegularDependency.REQUIRE;\n }\n // Normalize dependency and then request it from the manager\n var bangIndex = dependency.indexOf('!');\n if (bangIndex >= 0) {\n var strPluginId = moduleIdResolver.resolveModule(dependency.substr(0, bangIndex));\n var pluginParam = moduleIdResolver.resolveModule(dependency.substr(bangIndex + 1));\n var dependencyId = this._moduleIdProvider.getModuleId(strPluginId + '!' + pluginParam);\n var pluginId = this._moduleIdProvider.getModuleId(strPluginId);\n return new PluginDependency(dependencyId, pluginId, pluginParam);\n }\n return new RegularDependency(this._moduleIdProvider.getModuleId(moduleIdResolver.resolveModule(dependency)));\n };\n ModuleManager.prototype._normalizeDependencies = function (dependencies, moduleIdResolver) {\n var result = [], resultLen = 0;\n for (var i = 0, len = dependencies.length; i < len; i++) {\n result[resultLen++] = this._normalizeDependency(dependencies[i], moduleIdResolver);\n }\n return result;\n };\n ModuleManager.prototype._relativeRequire = function (moduleIdResolver, dependencies, callback, errorback) {\n if (typeof dependencies === 'string') {\n return this.synchronousRequire(dependencies, moduleIdResolver);\n }\n this.defineModule(AMDLoader.Utilities.generateAnonymousModule(), dependencies, callback, errorback, null, moduleIdResolver);\n };\n /**\n * Require synchronously a module by its absolute id. If the module is not loaded, an exception will be thrown.\n * @param id The unique and absolute id of the required module\n * @return The exports of module 'id'\n */\n ModuleManager.prototype.synchronousRequire = function (_strModuleId, moduleIdResolver) {\n if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(_strModuleId); }\n var dependency = this._normalizeDependency(_strModuleId, moduleIdResolver);\n var m = this._modules2[dependency.id];\n if (!m) {\n throw new Error('Check dependency list! Synchronous require cannot resolve module \\'' + _strModuleId + '\\'. This is the first mention of this module!');\n }\n if (!m.isComplete()) {\n throw new Error('Check dependency list! Synchronous require cannot resolve module \\'' + _strModuleId + '\\'. This module has not been resolved completely yet.');\n }\n return m.exports;\n };\n ModuleManager.prototype.configure = function (params, shouldOverwrite) {\n var oldShouldRecordStats = this._config.shouldRecordStats();\n if (shouldOverwrite) {\n this._config = new AMDLoader.Configuration(this._env, params);\n }\n else {\n this._config = this._config.cloneAndMerge(params);\n }\n if (this._config.shouldRecordStats() && !oldShouldRecordStats) {\n this._recorder = null;\n }\n };\n ModuleManager.prototype.getConfig = function () {\n return this._config;\n };\n /**\n * Callback from the scriptLoader when a module has been loaded.\n * This means its code is available and has been executed.\n */\n ModuleManager.prototype._onLoad = function (moduleId) {\n if (this._currentAnnonymousDefineCall !== null) {\n var defineCall = this._currentAnnonymousDefineCall;\n this._currentAnnonymousDefineCall = null;\n // Hit an anonymous define call\n this.defineModule(this._moduleIdProvider.getStrModuleId(moduleId), defineCall.dependencies, defineCall.callback, null, defineCall.stack);\n }\n };\n ModuleManager.prototype._createLoadError = function (moduleId, err) {\n var _this = this;\n var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);\n var neededBy = (this._inverseDependencies2[moduleId] || []).map(function (intModuleId) { return _this._moduleIdProvider.getStrModuleId(intModuleId); });\n return {\n errorCode: 'load',\n moduleId: strModuleId,\n neededBy: neededBy,\n detail: err\n };\n };\n /**\n * Callback from the scriptLoader when a module hasn't been loaded.\n * This means that the script was not found (e.g. 404) or there was an error in the script.\n */\n ModuleManager.prototype._onLoadError = function (moduleId, err) {\n var error = this._createLoadError(moduleId, err);\n // Find any 'local' error handlers, walk the entire chain of inverse dependencies if necessary.\n var seenModuleId = [];\n for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {\n seenModuleId[i] = false;\n }\n var someoneNotified = false;\n var queue = [];\n queue.push(moduleId);\n seenModuleId[moduleId] = true;\n while (queue.length > 0) {\n var queueElement = queue.shift();\n var m = this._modules2[queueElement];\n if (m) {\n someoneNotified = m.onDependencyError(error) || someoneNotified;\n }\n var inverseDeps = this._inverseDependencies2[queueElement];\n if (inverseDeps) {\n for (var i = 0, len = inverseDeps.length; i < len; i++) {\n var inverseDep = inverseDeps[i];\n if (!seenModuleId[inverseDep]) {\n queue.push(inverseDep);\n seenModuleId[inverseDep] = true;\n }\n }\n }\n }\n if (!someoneNotified) {\n this._config.onError(error);\n }\n };\n /**\n * Walks (recursively) the dependencies of 'from' in search of 'to'.\n * Returns true if there is such a path or false otherwise.\n * @param from Module id to start at\n * @param to Module id to look for\n */\n ModuleManager.prototype._hasDependencyPath = function (fromId, toId) {\n var from = this._modules2[fromId];\n if (!from) {\n return false;\n }\n var inQueue = [];\n for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {\n inQueue[i] = false;\n }\n var queue = [];\n // Insert 'from' in queue\n queue.push(from);\n inQueue[fromId] = true;\n while (queue.length > 0) {\n // Pop first inserted element of queue\n var element = queue.shift();\n var dependencies = element.dependencies;\n if (dependencies) {\n // Walk the element's dependencies\n for (var i = 0, len = dependencies.length; i < len; i++) {\n var dependency = dependencies[i];\n if (dependency.id === toId) {\n // There is a path to 'to'\n return true;\n }\n var dependencyModule = this._modules2[dependency.id];\n if (dependencyModule && !inQueue[dependency.id]) {\n // Insert 'dependency' in queue\n inQueue[dependency.id] = true;\n queue.push(dependencyModule);\n }\n }\n }\n }\n // There is no path to 'to'\n return false;\n };\n /**\n * Walks (recursively) the dependencies of 'from' in search of 'to'.\n * Returns cycle as array.\n * @param from Module id to start at\n * @param to Module id to look for\n */\n ModuleManager.prototype._findCyclePath = function (fromId, toId, depth) {\n if (fromId === toId || depth === 50) {\n return [fromId];\n }\n var from = this._modules2[fromId];\n if (!from) {\n return null;\n }\n // Walk the element's dependencies\n var dependencies = from.dependencies;\n for (var i = 0, len = dependencies.length; i < len; i++) {\n var path = this._findCyclePath(dependencies[i].id, toId, depth + 1);\n if (path !== null) {\n path.push(fromId);\n return path;\n }\n }\n return null;\n };\n /**\n * Create the local 'require' that is passed into modules\n */\n ModuleManager.prototype._createRequire = function (moduleIdResolver) {\n var _this = this;\n var result = (function (dependencies, callback, errorback) {\n return _this._relativeRequire(moduleIdResolver, dependencies, callback, errorback);\n });\n result.toUrl = function (id) {\n return _this._config.requireToUrl(moduleIdResolver.resolveModule(id));\n };\n result.getStats = function () {\n return _this.getLoaderEvents();\n };\n result.__$__nodeRequire = AMDLoader.global.nodeRequire;\n return result;\n };\n ModuleManager.prototype._loadModule = function (moduleId) {\n var _this = this;\n if (this._modules2[moduleId] || this._knownModules2[moduleId]) {\n // known module\n return;\n }\n this._knownModules2[moduleId] = true;\n var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);\n var paths = this._config.moduleIdToPaths(strModuleId);\n if (this._env.isNode && strModuleId.indexOf('/') === -1) {\n paths.push('node|' + strModuleId);\n }\n var lastPathIndex = -1;\n var loadNextPath = function (err) {\n lastPathIndex++;\n if (lastPathIndex >= paths.length) {\n // No more paths to try\n _this._onLoadError(moduleId, err);\n }\n else {\n var currentPath_1 = paths[lastPathIndex];\n var recorder_1 = _this.getRecorder();\n if (_this._config.isBuild() && currentPath_1 === 'empty:') {\n _this._buildInfoPath[moduleId] = currentPath_1;\n _this.defineModule(_this._moduleIdProvider.getStrModuleId(moduleId), [], null, null, null);\n _this._onLoad(moduleId);\n return;\n }\n recorder_1.record(10 /* BeginLoadingScript */, currentPath_1);\n _this._scriptLoader.load(_this, currentPath_1, function () {\n if (_this._config.isBuild()) {\n _this._buildInfoPath[moduleId] = currentPath_1;\n }\n recorder_1.record(11 /* EndLoadingScriptOK */, currentPath_1);\n _this._onLoad(moduleId);\n }, function (err) {\n recorder_1.record(12 /* EndLoadingScriptError */, currentPath_1);\n loadNextPath(err);\n });\n }\n };\n loadNextPath(null);\n };\n /**\n * Resolve a plugin dependency with the plugin loaded & complete\n * @param module The module that has this dependency\n * @param pluginDependency The semi-normalized dependency that appears in the module. e.g. 'vs/css!./mycssfile'. Only the plugin part (before !) is normalized\n * @param plugin The plugin (what the plugin exports)\n */\n ModuleManager.prototype._loadPluginDependency = function (plugin, pluginDependency) {\n var _this = this;\n if (this._modules2[pluginDependency.id] || this._knownModules2[pluginDependency.id]) {\n // known module\n return;\n }\n this._knownModules2[pluginDependency.id] = true;\n // Delegate the loading of the resource to the plugin\n var load = (function (value) {\n _this.defineModule(_this._moduleIdProvider.getStrModuleId(pluginDependency.id), [], value, null, null);\n });\n load.error = function (err) {\n _this._config.onError(_this._createLoadError(pluginDependency.id, err));\n };\n plugin.load(pluginDependency.pluginParam, this._createRequire(ModuleIdResolver.ROOT), load, this._config.getOptionsLiteral());\n };\n /**\n * Examine the dependencies of module 'module' and resolve them as needed.\n */\n ModuleManager.prototype._resolve = function (module) {\n var _this = this;\n var dependencies = module.dependencies;\n for (var i = 0, len = dependencies.length; i < len; i++) {\n var dependency = dependencies[i];\n if (dependency === RegularDependency.EXPORTS) {\n module.exportsPassedIn = true;\n module.unresolvedDependenciesCount--;\n continue;\n }\n if (dependency === RegularDependency.MODULE) {\n module.unresolvedDependenciesCount--;\n continue;\n }\n if (dependency === RegularDependency.REQUIRE) {\n module.unresolvedDependenciesCount--;\n continue;\n }\n var dependencyModule = this._modules2[dependency.id];\n if (dependencyModule && dependencyModule.isComplete()) {\n module.unresolvedDependenciesCount--;\n continue;\n }\n if (this._hasDependencyPath(dependency.id, module.id)) {\n console.warn('There is a dependency cycle between \\'' + this._moduleIdProvider.getStrModuleId(dependency.id) + '\\' and \\'' + this._moduleIdProvider.getStrModuleId(module.id) + '\\'. The cyclic path follows:');\n var cyclePath = this._findCyclePath(dependency.id, module.id, 0);\n cyclePath.reverse();\n cyclePath.push(dependency.id);\n console.warn(cyclePath.map(function (id) { return _this._moduleIdProvider.getStrModuleId(id); }).join(' => \\n'));\n // Break the cycle\n module.unresolvedDependenciesCount--;\n continue;\n }\n // record inverse dependency\n this._inverseDependencies2[dependency.id] = this._inverseDependencies2[dependency.id] || [];\n this._inverseDependencies2[dependency.id].push(module.id);\n if (dependency instanceof PluginDependency) {\n var plugin = this._modules2[dependency.pluginId];\n if (plugin && plugin.isComplete()) {\n this._loadPluginDependency(plugin.exports, dependency);\n continue;\n }\n // Record dependency for when the plugin gets loaded\n var inversePluginDeps = this._inversePluginDependencies2.get(dependency.pluginId);\n if (!inversePluginDeps) {\n inversePluginDeps = [];\n this._inversePluginDependencies2.set(dependency.pluginId, inversePluginDeps);\n }\n inversePluginDeps.push(dependency);\n this._loadModule(dependency.pluginId);\n continue;\n }\n this._loadModule(dependency.id);\n }\n if (module.unresolvedDependenciesCount === 0) {\n this._onModuleComplete(module);\n }\n };\n ModuleManager.prototype._onModuleComplete = function (module) {\n var _this = this;\n var recorder = this.getRecorder();\n if (module.isComplete()) {\n // already done\n return;\n }\n var dependencies = module.dependencies;\n var dependenciesValues = [];\n for (var i = 0, len = dependencies.length; i < len; i++) {\n var dependency = dependencies[i];\n if (dependency === RegularDependency.EXPORTS) {\n dependenciesValues[i] = module.exports;\n continue;\n }\n if (dependency === RegularDependency.MODULE) {\n dependenciesValues[i] = {\n id: module.strId,\n config: function () {\n return _this._config.getConfigForModule(module.strId);\n }\n };\n continue;\n }\n if (dependency === RegularDependency.REQUIRE) {\n dependenciesValues[i] = this._createRequire(module.moduleIdResolver);\n continue;\n }\n var dependencyModule = this._modules2[dependency.id];\n if (dependencyModule) {\n dependenciesValues[i] = dependencyModule.exports;\n continue;\n }\n dependenciesValues[i] = null;\n }\n module.complete(recorder, this._config, dependenciesValues);\n // Fetch and clear inverse dependencies\n var inverseDeps = this._inverseDependencies2[module.id];\n this._inverseDependencies2[module.id] = null;\n if (inverseDeps) {\n // Resolve one inverse dependency at a time, always\n // on the lookout for a completed module.\n for (var i = 0, len = inverseDeps.length; i < len; i++) {\n var inverseDependencyId = inverseDeps[i];\n var inverseDependency = this._modules2[inverseDependencyId];\n inverseDependency.unresolvedDependenciesCount--;\n if (inverseDependency.unresolvedDependenciesCount === 0) {\n this._onModuleComplete(inverseDependency);\n }\n }\n }\n var inversePluginDeps = this._inversePluginDependencies2.get(module.id);\n if (inversePluginDeps) {\n // This module is used as a plugin at least once\n // Fetch and clear these inverse plugin dependencies\n this._inversePluginDependencies2.delete(module.id);\n // Resolve plugin dependencies one at a time\n for (var i = 0, len = inversePluginDeps.length; i < len; i++) {\n this._loadPluginDependency(module.exports, inversePluginDeps[i]);\n }\n }\n };\n return ModuleManager;\n }());\n AMDLoader.ModuleManager = ModuleManager;\n})(AMDLoader || (AMDLoader = {}));\nvar define;\nvar AMDLoader;\n(function (AMDLoader) {\n var env = new AMDLoader.Environment();\n var moduleManager = null;\n var DefineFunc = function (id, dependencies, callback) {\n if (typeof id !== 'string') {\n callback = dependencies;\n dependencies = id;\n id = null;\n }\n if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {\n callback = dependencies;\n dependencies = null;\n }\n if (!dependencies) {\n dependencies = ['require', 'exports', 'module'];\n }\n if (id) {\n moduleManager.defineModule(id, dependencies, callback, null, null);\n }\n else {\n moduleManager.enqueueDefineAnonymousModule(dependencies, callback);\n }\n };\n DefineFunc.amd = {\n jQuery: true\n };\n var _requireFunc_config = function (params, shouldOverwrite) {\n if (shouldOverwrite === void 0) { shouldOverwrite = false; }\n moduleManager.configure(params, shouldOverwrite);\n };\n var RequireFunc = function () {\n if (arguments.length === 1) {\n if ((arguments[0] instanceof Object) && !Array.isArray(arguments[0])) {\n _requireFunc_config(arguments[0]);\n return;\n }\n if (typeof arguments[0] === 'string') {\n return moduleManager.synchronousRequire(arguments[0]);\n }\n }\n if (arguments.length === 2 || arguments.length === 3) {\n if (Array.isArray(arguments[0])) {\n moduleManager.defineModule(AMDLoader.Utilities.generateAnonymousModule(), arguments[0], arguments[1], arguments[2], null);\n return;\n }\n }\n throw new Error('Unrecognized require call');\n };\n RequireFunc.config = _requireFunc_config;\n RequireFunc.getConfig = function () {\n return moduleManager.getConfig().getOptionsLiteral();\n };\n RequireFunc.reset = function () {\n moduleManager = moduleManager.reset();\n };\n RequireFunc.getBuildInfo = function () {\n return moduleManager.getBuildInfo();\n };\n RequireFunc.getStats = function () {\n return moduleManager.getLoaderEvents();\n };\n function init() {\n if (typeof AMDLoader.global.require !== 'undefined' || typeof require !== 'undefined') {\n var _nodeRequire_1 = (AMDLoader.global.require || require);\n if (typeof _nodeRequire_1 === 'function' && typeof _nodeRequire_1.resolve === 'function') {\n // re-expose node's require function\n var nodeRequire = function (what) {\n moduleManager.getRecorder().record(33 /* NodeBeginNativeRequire */, what);\n try {\n return _nodeRequire_1(what);\n }\n finally {\n moduleManager.getRecorder().record(34 /* NodeEndNativeRequire */, what);\n }\n };\n AMDLoader.global.nodeRequire = nodeRequire;\n RequireFunc.nodeRequire = nodeRequire;\n RequireFunc.__$__nodeRequire = nodeRequire;\n }\n }\n if (env.isNode && !env.isElectronRenderer) {\n module.exports = RequireFunc;\n require = RequireFunc;\n }\n else {\n if (!env.isElectronRenderer) {\n AMDLoader.global.define = DefineFunc;\n }\n AMDLoader.global.require = RequireFunc;\n }\n }\n AMDLoader.init = init;\n if (typeof AMDLoader.global.define !== 'function' || !AMDLoader.global.define.amd) {\n moduleManager = new AMDLoader.ModuleManager(env, AMDLoader.createScriptLoader(env), DefineFunc, RequireFunc, AMDLoader.Utilities.getHighPerformanceTimestamp());\n // The global variable require can configure the loader\n if (typeof AMDLoader.global.require !== 'undefined' && typeof AMDLoader.global.require !== 'function') {\n RequireFunc.config(AMDLoader.global.require);\n }\n // This define is for the local closure defined in node in the case that the loader is concatenated\n define = function () {\n return DefineFunc.apply(null, arguments);\n };\n define.amd = DefineFunc.amd;\n if (typeof doNotInitLoader === 'undefined') {\n init();\n }\n }\n})(AMDLoader || (AMDLoader = {}));\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\n/**\n * Represents information about a specific difference between two sequences.\n */\nexport class DiffChange {\n\n\t/**\n\t * The position of the first element in the original sequence which\n\t * this change affects.\n\t */\n\tpublic originalStart: number;\n\n\t/**\n\t * The number of elements from the original sequence which were\n\t * affected.\n\t */\n\tpublic originalLength: number;\n\n\t/**\n\t * The position of the first element in the modified sequence which\n\t * this change affects.\n\t */\n\tpublic modifiedStart: number;\n\n\t/**\n\t * The number of elements from the modified sequence which were\n\t * affected (added).\n\t */\n\tpublic modifiedLength: number;\n\n\t/**\n\t * Constructs a new DiffChange with the given sequence information\n\t * and content.\n\t */\n\tconstructor(originalStart: number, originalLength: number, modifiedStart: number, modifiedLength: number) {\n\t\t//Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n\t\tthis.originalStart = originalStart;\n\t\tthis.originalLength = originalLength;\n\t\tthis.modifiedStart = modifiedStart;\n\t\tthis.modifiedLength = modifiedLength;\n\t}\n\n\t/**\n\t * The end point (exclusive) of the change in the original sequence.\n\t */\n\tpublic getOriginalEnd() {\n\t\treturn this.originalStart + this.originalLength;\n\t}\n\n\t/**\n\t * The end point (exclusive) of the change in the modified sequence.\n\t */\n\tpublic getModifiedEnd() {\n\t\treturn this.modifiedStart + this.modifiedLength;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { DiffChange } from 'vs/base/common/diff/diffChange';\n\n\nfunction createStringSequence(a: string): ISequence {\n\n\treturn {\n\t\tgetLength() { return a.length; },\n\t\tgetElementHash(pos: number) { return a[pos]; }\n\t};\n}\n\nexport function stringDiff(original: string, modified: string, pretty: boolean): IDiffChange[] {\n\treturn new LcsDiff(createStringSequence(original), createStringSequence(modified)).ComputeDiff(pretty);\n}\n\n\nexport interface ISequence {\n\tgetLength(): number;\n\tgetElementHash(index: number): string;\n}\n\nexport interface IDiffChange {\n\t/**\n\t * The position of the first element in the original sequence which\n\t * this change affects.\n\t */\n\toriginalStart: number;\n\n\t/**\n\t * The number of elements from the original sequence which were\n\t * affected.\n\t */\n\toriginalLength: number;\n\n\t/**\n\t * The position of the first element in the modified sequence which\n\t * this change affects.\n\t */\n\tmodifiedStart: number;\n\n\t/**\n\t * The number of elements from the modified sequence which were\n\t * affected (added).\n\t */\n\tmodifiedLength: number;\n}\n\nexport interface IContinueProcessingPredicate {\n\t(furthestOriginalIndex: number, originalSequence: ISequence, matchLengthOfLongest: number): boolean;\n}\n\n//\n// The code below has been ported from a C# implementation in VS\n//\n\nexport class Debug {\n\n\tpublic static Assert(condition: boolean, message: string): void {\n\t\tif (!condition) {\n\t\t\tthrow new Error(message);\n\t\t}\n\t}\n}\n\nexport class MyArray {\n\t/**\n\t * Copies a range of elements from an Array starting at the specified source index and pastes\n\t * them to another Array starting at the specified destination index. The length and the indexes\n\t * are specified as 64-bit integers.\n\t * sourceArray:\n\t *\t\tThe Array that contains the data to copy.\n\t * sourceIndex:\n\t *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n\t * destinationArray:\n\t *\t\tThe Array that receives the data.\n\t * destinationIndex:\n\t *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n\t * length:\n\t *\t\tA 64-bit integer that represents the number of elements to copy.\n\t */\n\tpublic static Copy(sourceArray: any[], sourceIndex: number, destinationArray: any[], destinationIndex: number, length: number) {\n\t\tfor (let i = 0; i < length; i++) {\n\t\t\tdestinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n\t\t}\n\t}\n}\n\n//*****************************************************************************\n// LcsDiff.cs\n//\n// An implementation of the difference algorithm described in\n// \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n//\n// Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve\n//*****************************************************************************\n\n// Our total memory usage for storing history is (worst-case):\n// 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)\n// 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB\nlet MaxDifferencesHistory = 1447;\n//let MaxDifferencesHistory = 100;\n\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 * MarktNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nclass DiffChangeHelper {\n\n\tprivate m_changes: DiffChange[];\n\tprivate m_originalStart: number;\n\tprivate m_modifiedStart: number;\n\tprivate m_originalCount: number;\n\tprivate m_modifiedCount: number;\n\n\t/**\n\t * Constructs a new DiffChangeHelper for the given DiffSequences.\n\t */\n\tconstructor() {\n\t\tthis.m_changes = [];\n\t\tthis.m_originalStart = Number.MAX_VALUE;\n\t\tthis.m_modifiedStart = Number.MAX_VALUE;\n\t\tthis.m_originalCount = 0;\n\t\tthis.m_modifiedCount = 0;\n\t}\n\n\t/**\n\t * Marks the beginning of the next change in the set of differences.\n\t */\n\tpublic MarkNextChange(): void {\n\t\t// Only add to the list if there is something to add\n\t\tif (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n\t\t\t// Add the new change to our list\n\t\t\tthis.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount,\n\t\t\t\tthis.m_modifiedStart, this.m_modifiedCount));\n\t\t}\n\n\t\t// Reset for the next change\n\t\tthis.m_originalCount = 0;\n\t\tthis.m_modifiedCount = 0;\n\t\tthis.m_originalStart = Number.MAX_VALUE;\n\t\tthis.m_modifiedStart = Number.MAX_VALUE;\n\t}\n\n\t/**\n\t * Adds the original element at the given position to the elements\n\t * affected by the current change. The modified index gives context\n\t * to the change position with respect to the original sequence.\n\t * @param originalIndex The index of the original element to add.\n\t * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n\t */\n\tpublic AddOriginalElement(originalIndex: number, modifiedIndex: number) {\n\t\t// The 'true' start index is the smallest of the ones we've seen\n\t\tthis.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n\t\tthis.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n\n\t\tthis.m_originalCount++;\n\t}\n\n\t/**\n\t * Adds the modified element at the given position to the elements\n\t * affected by the current change. The original index gives context\n\t * to the change position with respect to the modified sequence.\n\t * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n\t * @param modifiedIndex The index of the modified element to add.\n\t */\n\tpublic AddModifiedElement(originalIndex: number, modifiedIndex: number): void {\n\t\t// The 'true' start index is the smallest of the ones we've seen\n\t\tthis.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n\t\tthis.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n\n\t\tthis.m_modifiedCount++;\n\t}\n\n\t/**\n\t * Retrieves all of the changes marked by the class.\n\t */\n\tpublic getChanges(): DiffChange[] {\n\t\tif (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n\t\t\t// Finish up on whatever is left\n\t\t\tthis.MarkNextChange();\n\t\t}\n\n\t\treturn this.m_changes;\n\t}\n\n\t/**\n\t * Retrieves all of the changes marked by the class in the reverse order\n\t */\n\tpublic getReverseChanges(): DiffChange[] {\n\t\tif (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n\t\t\t// Finish up on whatever is left\n\t\t\tthis.MarkNextChange();\n\t\t}\n\n\t\tthis.m_changes.reverse();\n\t\treturn this.m_changes;\n\t}\n\n}\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\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\tprivate OriginalSequence: ISequence;\n\tprivate ModifiedSequence: ISequence;\n\tprivate ContinueProcessingPredicate: IContinueProcessingPredicate;\n\n\tprivate m_originalIds: number[];\n\tprivate m_modifiedIds: number[];\n\tprivate m_forwardHistory: number[][];\n\tprivate m_reverseHistory: number[][];\n\n\t/**\n\t * Constructs the DiffFinder\n\t */\n\tconstructor(originalSequence: ISequence, newSequence: ISequence, continueProcessingPredicate: IContinueProcessingPredicate = null) {\n\t\tthis.OriginalSequence = originalSequence;\n\t\tthis.ModifiedSequence = newSequence;\n\t\tthis.ContinueProcessingPredicate = continueProcessingPredicate;\n\t\tthis.m_originalIds = [];\n\t\tthis.m_modifiedIds = [];\n\n\t\tthis.m_forwardHistory = [];\n\t\tthis.m_reverseHistory = [];\n\n\t\tthis.ComputeUniqueIdentifiers();\n\t}\n\n\tprivate ComputeUniqueIdentifiers(): void {\n\t\tlet originalSequenceLength = this.OriginalSequence.getLength();\n\t\tlet modifiedSequenceLength = this.ModifiedSequence.getLength();\n\t\tthis.m_originalIds = new Array<number>(originalSequenceLength);\n\t\tthis.m_modifiedIds = new Array<number>(modifiedSequenceLength);\n\n\t\t// Create a new hash table for unique elements from the original\n\t\t// sequence.\n\t\tlet hashTable: { [key: string]: number; } = {};\n\t\tlet currentUniqueId = 1;\n\t\tlet i: number;\n\n\t\t// Fill up the hash table for unique elements\n\t\tfor (i = 0; i < originalSequenceLength; i++) {\n\t\t\tlet originalElementHash = this.OriginalSequence.getElementHash(i);\n\t\t\tif (!hasOwnProperty.call(hashTable, originalElementHash)) {\n\t\t\t\t// No entry in the hashtable so this is a new unique element.\n\t\t\t\t// Assign the element a new unique identifier and add it to the\n\t\t\t\t// hash table\n\t\t\t\tthis.m_originalIds[i] = currentUniqueId++;\n\t\t\t\thashTable[originalElementHash] = this.m_originalIds[i];\n\t\t\t} else {\n\t\t\t\tthis.m_originalIds[i] = hashTable[originalElementHash];\n\t\t\t}\n\t\t}\n\n\t\t// Now match up modified elements\n\t\tfor (i = 0; i < modifiedSequenceLength; i++) {\n\t\t\tlet modifiedElementHash = this.ModifiedSequence.getElementHash(i);\n\t\t\tif (!hasOwnProperty.call(hashTable, modifiedElementHash)) {\n\t\t\t\tthis.m_modifiedIds[i] = currentUniqueId++;\n\t\t\t\thashTable[modifiedElementHash] = this.m_modifiedIds[i];\n\t\t\t} else {\n\t\t\t\tthis.m_modifiedIds[i] = hashTable[modifiedElementHash];\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate ElementsAreEqual(originalIndex: number, newIndex: number): boolean {\n\t\treturn this.m_originalIds[originalIndex] === this.m_modifiedIds[newIndex];\n\t}\n\n\tprivate OriginalElementsAreEqual(index1: number, index2: number): boolean {\n\t\treturn this.m_originalIds[index1] === this.m_originalIds[index2];\n\t}\n\n\tprivate ModifiedElementsAreEqual(index1: number, index2: number): boolean {\n\t\treturn this.m_modifiedIds[index1] === this.m_modifiedIds[index2];\n\t}\n\n\tpublic ComputeDiff(pretty: boolean): IDiffChange[] {\n\t\treturn this._ComputeDiff(0, this.OriginalSequence.getLength() - 1, 0, this.ModifiedSequence.getLength() - 1, pretty);\n\t}\n\n\t/**\n\t * Computes the differences between the original and modified input\n\t * sequences on the bounded range.\n\t * @returns An array of the differences between the two input sequences.\n\t */\n\tprivate _ComputeDiff(originalStart: number, originalEnd: number, modifiedStart: number, modifiedEnd: number, pretty: boolean): DiffChange[] {\n\t\tlet quitEarlyArr = [false];\n\t\tlet changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n\n\t\tif (pretty) {\n\t\t\t// We have to clean up the computed diff to be more intuitive\n\t\t\t// but it turns out this cannot be done correctly until the entire set\n\t\t\t// of diffs have been computed\n\t\t\treturn this.ShiftChanges(changes);\n\t\t}\n\n\t\treturn changes;\n\t}\n\n\t/**\n\t * Private helper method which computes the differences on the bounded range\n\t * recursively.\n\t * @returns An array of the differences between the two input sequences.\n\t */\n\tprivate ComputeDiffRecursive(originalStart: number, originalEnd: number, modifiedStart: number, modifiedEnd: number, quitEarlyArr: boolean[]): DiffChange[] {\n\t\tquitEarlyArr[0] = false;\n\n\t\t// Find the start of the differences\n\t\twhile (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n\t\t\toriginalStart++;\n\t\t\tmodifiedStart++;\n\t\t}\n\n\t\t// Find the end of the differences\n\t\twhile (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n\t\t\toriginalEnd--;\n\t\t\tmodifiedEnd--;\n\t\t}\n\n\t\t// In the special case where we either have all insertions or all deletions or the sequences are identical\n\t\tif (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n\t\t\tlet changes: DiffChange[];\n\n\t\t\tif (modifiedStart <= modifiedEnd) {\n\t\t\t\tDebug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n\n\t\t\t\t// All insertions\n\t\t\t\tchanges = [\n\t\t\t\t\tnew DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n\t\t\t\t];\n\t\t\t} else if (originalStart <= originalEnd) {\n\t\t\t\tDebug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n\n\t\t\t\t// All deletions\n\t\t\t\tchanges = [\n\t\t\t\t\tnew DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n\t\t\t\t];\n\t\t\t} else {\n\t\t\t\tDebug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n\t\t\t\tDebug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n\n\t\t\t\t// Identical sequences - No differences\n\t\t\t\tchanges = [];\n\t\t\t}\n\n\t\t\treturn changes;\n\t\t}\n\n\t\t// This problem can be solved using the Divide-And-Conquer technique.\n\t\tlet midOriginalArr = [0], midModifiedArr = [0];\n\t\tlet result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n\n\t\tlet midOriginal = midOriginalArr[0];\n\t\tlet midModified = midModifiedArr[0];\n\n\t\tif (result !== null) {\n\t\t\t// Result is not-null when there was enough memory to compute the changes while\n\t\t\t// searching for the recursion point\n\t\t\treturn result;\n\t\t} else if (!quitEarlyArr[0]) {\n\t\t\t// We can break the problem down recursively by finding the changes in the\n\t\t\t// First Half: (originalStart, modifiedStart) to (midOriginal, midModified)\n\t\t\t// Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n\t\t\t// NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n\n\t\t\tlet leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n\t\t\tlet rightChanges: DiffChange[] = [];\n\n\t\t\tif (!quitEarlyArr[0]) {\n\t\t\t\trightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n\t\t\t} else {\n\t\t\t\t// We did't have time to finish the first half, so we don't have time to compute this half.\n\t\t\t\t// Consider the entire rest of the sequence different.\n\t\t\t\trightChanges = [\n\t\t\t\t\tnew DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n\t\t\t\t];\n\t\t\t}\n\n\t\t\treturn this.ConcatenateChanges(leftChanges, rightChanges);\n\t\t}\n\n\t\t// If we hit here, we quit early, and so can't return anything meaningful\n\t\treturn [\n\t\t\tnew DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n\t\t];\n\t}\n\n\tprivate WALKTRACE(diagonalForwardBase: number, diagonalForwardStart: number, diagonalForwardEnd: number, diagonalForwardOffset: number,\n\t\tdiagonalReverseBase: number, diagonalReverseStart: number, diagonalReverseEnd: number, diagonalReverseOffset: number,\n\t\tforwardPoints: number[], reversePoints: number[],\n\t\toriginalIndex: number, originalEnd: number, midOriginalArr: number[],\n\t\tmodifiedIndex: number, modifiedEnd: number, midModifiedArr: number[],\n\t\tdeltaIsEven: boolean, quitEarlyArr: boolean[]): DiffChange[] {\n\t\tlet forwardChanges: DiffChange[] = null, reverseChanges: DiffChange[] = null;\n\n\t\t// First, walk backward through the forward diagonals history\n\t\tlet changeHelper = new DiffChangeHelper();\n\t\tlet diagonalMin = diagonalForwardStart;\n\t\tlet diagonalMax = diagonalForwardEnd;\n\t\tlet diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n\t\tlet lastOriginalIndex = Number.MIN_VALUE;\n\t\tlet historyIndex = this.m_forwardHistory.length - 1;\n\t\tlet diagonal: number;\n\n\t\tdo {\n\t\t\t// Get the diagonal index from the relative diagonal number\n\t\t\tdiagonal = diagonalRelative + diagonalForwardBase;\n\n\t\t\t// Figure out where we came from\n\t\t\tif (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n\t\t\t\t// Vertical line (the element is an insert)\n\t\t\t\toriginalIndex = forwardPoints[diagonal + 1];\n\t\t\t\tmodifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n\t\t\t\tif (originalIndex < lastOriginalIndex) {\n\t\t\t\t\tchangeHelper.MarkNextChange();\n\t\t\t\t}\n\t\t\t\tlastOriginalIndex = originalIndex;\n\t\t\t\tchangeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n\t\t\t\tdiagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n\t\t\t} else {\n\t\t\t\t// Horizontal line (the element is a deletion)\n\t\t\t\toriginalIndex = forwardPoints[diagonal - 1] + 1;\n\t\t\t\tmodifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n\t\t\t\tif (originalIndex < lastOriginalIndex) {\n\t\t\t\t\tchangeHelper.MarkNextChange();\n\t\t\t\t}\n\t\t\t\tlastOriginalIndex = originalIndex - 1;\n\t\t\t\tchangeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n\t\t\t\tdiagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n\t\t\t}\n\n\t\t\tif (historyIndex >= 0) {\n\t\t\t\tforwardPoints = this.m_forwardHistory[historyIndex];\n\t\t\t\tdiagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n\t\t\t\tdiagonalMin = 1;\n\t\t\t\tdiagonalMax = forwardPoints.length - 1;\n\t\t\t}\n\t\t} while (--historyIndex >= -1);\n\n\t\t// Ironically, we get the forward changes as the reverse of the\n\t\t// order we added them since we technically added them backwards\n\t\tforwardChanges = changeHelper.getReverseChanges();\n\n\t\tif (quitEarlyArr[0]) {\n\t\t\t// TODO: Calculate a partial from the reverse diagonals.\n\t\t\t// For now, just assume everything after the midOriginal/midModified point is a diff\n\n\t\t\tlet originalStartPoint = midOriginalArr[0] + 1;\n\t\t\tlet modifiedStartPoint = midModifiedArr[0] + 1;\n\n\t\t\tif (forwardChanges !== null && forwardChanges.length > 0) {\n\t\t\t\tlet lastForwardChange = forwardChanges[forwardChanges.length - 1];\n\t\t\t\toriginalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n\t\t\t\tmodifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n\t\t\t}\n\n\t\t\treverseChanges = [\n\t\t\t\tnew DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1,\n\t\t\t\t\tmodifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n\t\t\t];\n\t\t} else {\n\t\t\t// Now walk backward through the reverse diagonals history\n\t\t\tchangeHelper = new DiffChangeHelper();\n\t\t\tdiagonalMin = diagonalReverseStart;\n\t\t\tdiagonalMax = diagonalReverseEnd;\n\t\t\tdiagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n\t\t\tlastOriginalIndex = Number.MAX_VALUE;\n\t\t\thistoryIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n\n\t\t\tdo {\n\t\t\t\t// Get the diagonal index from the relative diagonal number\n\t\t\t\tdiagonal = diagonalRelative + diagonalReverseBase;\n\n\t\t\t\t// Figure out where we came from\n\t\t\t\tif (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n\t\t\t\t\t// Horizontal line (the element is a deletion))\n\t\t\t\t\toriginalIndex = reversePoints[diagonal + 1] - 1;\n\t\t\t\t\tmodifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n\t\t\t\t\tif (originalIndex > lastOriginalIndex) {\n\t\t\t\t\t\tchangeHelper.MarkNextChange();\n\t\t\t\t\t}\n\t\t\t\t\tlastOriginalIndex = originalIndex + 1;\n\t\t\t\t\tchangeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n\t\t\t\t\tdiagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n\t\t\t\t} else {\n\t\t\t\t\t// Vertical line (the element is an insertion)\n\t\t\t\t\toriginalIndex = reversePoints[diagonal - 1];\n\t\t\t\t\tmodifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n\t\t\t\t\tif (originalIndex > lastOriginalIndex) {\n\t\t\t\t\t\tchangeHelper.MarkNextChange();\n\t\t\t\t\t}\n\t\t\t\t\tlastOriginalIndex = originalIndex;\n\t\t\t\t\tchangeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n\t\t\t\t\tdiagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n\t\t\t\t}\n\n\t\t\t\tif (historyIndex >= 0) {\n\t\t\t\t\treversePoints = this.m_reverseHistory[historyIndex];\n\t\t\t\t\tdiagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n\t\t\t\t\tdiagonalMin = 1;\n\t\t\t\t\tdiagonalMax = reversePoints.length - 1;\n\t\t\t\t}\n\t\t\t} while (--historyIndex >= -1);\n\n\t\t\t// There are cases where the reverse history will find diffs that\n\t\t\t// are correct, but not intuitive, so we need shift them.\n\t\t\treverseChanges = changeHelper.getChanges();\n\t\t}\n\n\t\treturn this.ConcatenateChanges(forwardChanges, reverseChanges);\n\t}\n\n\t/**\n\t * Given the range to compute the diff on, this method finds the point:\n\t * (midOriginal, midModified)\n\t * that exists in the middle of the LCS of the two sequences and\n\t * is the point at which the LCS problem may be broken down recursively.\n\t * This method will try to keep the LCS trace in memory. If the LCS recursion\n\t * point is calculated and the full trace is available in memory, then this method\n\t * will return the change list.\n\t * @param originalStart The start bound of the original sequence range\n\t * @param originalEnd The end bound of the original sequence range\n\t * @param modifiedStart The start bound of the modified sequence range\n\t * @param modifiedEnd The end bound of the modified sequence range\n\t * @param midOriginal The middle point of the original sequence range\n\t * @param midModified The middle point of the modified sequence range\n\t * @returns The diff changes, if available, otherwise null\n\t */\n\tprivate ComputeRecursionPoint(originalStart: number, originalEnd: number, modifiedStart: number, modifiedEnd: number, midOriginalArr: number[], midModifiedArr: number[], quitEarlyArr: boolean[]) {\n\t\tlet originalIndex: number, modifiedIndex: number;\n\t\tlet diagonalForwardStart = 0, diagonalForwardEnd = 0;\n\t\tlet diagonalReverseStart = 0, diagonalReverseEnd = 0;\n\t\tlet numDifferences: number;\n\n\t\t// To traverse the edit graph and produce the proper LCS, our actual\n\t\t// start position is just outside the given boundary\n\t\toriginalStart--;\n\t\tmodifiedStart--;\n\n\t\t// We set these up to make the compiler happy, but they will\n\t\t// be replaced before we return with the actual recursion point\n\t\tmidOriginalArr[0] = 0;\n\t\tmidModifiedArr[0] = 0;\n\n\t\t// Clear out the history\n\t\tthis.m_forwardHistory = [];\n\t\tthis.m_reverseHistory = [];\n\n\t\t// Each cell in the two arrays corresponds to a diagonal in the edit graph.\n\t\t// The integer value in the cell represents the originalIndex of the furthest\n\t\t// reaching point found so far that ends in that diagonal.\n\t\t// The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n\t\tlet maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n\t\tlet numDiagonals = maxDifferences + 1;\n\t\tlet forwardPoints: number[] = new Array<number>(numDiagonals);\n\t\tlet reversePoints: number[] = new Array<number>(numDiagonals);\n\t\t// diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n\t\t// diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n\t\tlet diagonalForwardBase = (modifiedEnd - modifiedStart);\n\t\tlet diagonalReverseBase = (originalEnd - originalStart);\n\t\t// diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n\t\t// diagonal number (relative to diagonalForwardBase)\n\t\t// diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n\t\t// diagonal number (relative to diagonalReverseBase)\n\t\tlet diagonalForwardOffset = (originalStart - modifiedStart);\n\t\tlet diagonalReverseOffset = (originalEnd - modifiedEnd);\n\n\t\t// delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n\t\t// relative to the start diagonal with diagonal numbers relative to the end diagonal.\n\t\t// The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n\t\tlet delta = diagonalReverseBase - diagonalForwardBase;\n\t\tlet deltaIsEven = (delta % 2 === 0);\n\n\t\t// Here we set up the start and end points as the furthest points found so far\n\t\t// in both the forward and reverse directions, respectively\n\t\tforwardPoints[diagonalForwardBase] = originalStart;\n\t\treversePoints[diagonalReverseBase] = originalEnd;\n\n\t\t// Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n\t\tquitEarlyArr[0] = false;\n\n\n\n\t\t// A couple of points:\n\t\t// --With this method, we iterate on the number of differences between the two sequences.\n\t\t// The more differences there actually are, the longer this will take.\n\t\t// --Also, as the number of differences increases, we have to search on diagonals further\n\t\t// away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n\t\t// --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n\t\t// is even and odd diagonals only when numDifferences is odd.\n\t\tlet diagonal: number, tempOriginalIndex: number;\n\t\tfor (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n\t\t\tlet furthestOriginalIndex = 0;\n\t\t\tlet furthestModifiedIndex = 0;\n\n\t\t\t// Run the algorithm in the forward direction\n\t\t\tdiagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n\t\t\tdiagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n\t\t\tfor (diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n\t\t\t\t// STEP 1: We extend the furthest reaching point in the present diagonal\n\t\t\t\t// by looking at the diagonals above and below and picking the one whose point\n\t\t\t\t// is further away from the start point (originalStart, modifiedStart)\n\t\t\t\tif (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n\t\t\t\t\toriginalIndex = forwardPoints[diagonal + 1];\n\t\t\t\t} else {\n\t\t\t\t\toriginalIndex = forwardPoints[diagonal - 1] + 1;\n\t\t\t\t}\n\t\t\t\tmodifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n\n\t\t\t\t// Save the current originalIndex so we can test for false overlap in step 3\n\t\t\t\ttempOriginalIndex = originalIndex;\n\n\t\t\t\t// STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n\t\t\t\t// so long as the elements are equal.\n\t\t\t\twhile (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n\t\t\t\t\toriginalIndex++;\n\t\t\t\t\tmodifiedIndex++;\n\t\t\t\t}\n\t\t\t\tforwardPoints[diagonal] = originalIndex;\n\n\t\t\t\tif (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n\t\t\t\t\tfurthestOriginalIndex = originalIndex;\n\t\t\t\t\tfurthestModifiedIndex = modifiedIndex;\n\t\t\t\t}\n\n\t\t\t\t// STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n\t\t\t\t// and diagonal is in the range of reverse diagonals computed for numDifferences-1\n\t\t\t\t// (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n\t\t\t\t// then check for overlap.\n\t\t\t\tif (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n\t\t\t\t\tif (originalIndex >= reversePoints[diagonal]) {\n\t\t\t\t\t\tmidOriginalArr[0] = originalIndex;\n\t\t\t\t\t\tmidModifiedArr[0] = modifiedIndex;\n\n\t\t\t\t\t\tif (tempOriginalIndex <= reversePoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n\t\t\t\t\t\t\t// BINGO! We overlapped, and we have the full trace in memory!\n\t\t\t\t\t\t\treturn this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset,\n\t\t\t\t\t\t\t\tdiagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset,\n\t\t\t\t\t\t\t\tforwardPoints, reversePoints,\n\t\t\t\t\t\t\t\toriginalIndex, originalEnd, midOriginalArr,\n\t\t\t\t\t\t\t\tmodifiedIndex, modifiedEnd, midModifiedArr,\n\t\t\t\t\t\t\t\tdeltaIsEven, quitEarlyArr\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Either false overlap, or we didn't have enough memory for the full trace\n\t\t\t\t\t\t\t// Just return the recursion point\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Check to see if we should be quitting early, before moving on to the next iteration.\n\t\t\tlet matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n\n\t\t\tif (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {\n\t\t\t\t// We can't finish, so skip ahead to generating a result from what we have.\n\t\t\t\tquitEarlyArr[0] = true;\n\n\t\t\t\t// Use the furthest distance we got in the forward direction.\n\t\t\t\tmidOriginalArr[0] = furthestOriginalIndex;\n\t\t\t\tmidModifiedArr[0] = furthestModifiedIndex;\n\n\t\t\t\tif (matchLengthOfLongest > 0 && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n\t\t\t\t\t// Enough of the history is in memory to walk it backwards\n\t\t\t\t\treturn this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset,\n\t\t\t\t\t\tdiagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset,\n\t\t\t\t\t\tforwardPoints, reversePoints,\n\t\t\t\t\t\toriginalIndex, originalEnd, midOriginalArr,\n\t\t\t\t\t\tmodifiedIndex, modifiedEnd, midModifiedArr,\n\t\t\t\t\t\tdeltaIsEven, quitEarlyArr\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\t// We didn't actually remember enough of the history.\n\n\t\t\t\t\t//Since we are quiting the diff early, we need to shift back the originalStart and modified start\n\t\t\t\t\t//back into the boundary limits since we decremented their value above beyond the boundary limit.\n\t\t\t\t\toriginalStart++;\n\t\t\t\t\tmodifiedStart++;\n\n\t\t\t\t\treturn [\n\t\t\t\t\t\tnew DiffChange(originalStart, originalEnd - originalStart + 1,\n\t\t\t\t\t\t\tmodifiedStart, modifiedEnd - modifiedStart + 1)\n\t\t\t\t\t];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Run the algorithm in the reverse direction\n\t\t\tdiagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n\t\t\tdiagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n\t\t\tfor (diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n\t\t\t\t// STEP 1: We extend the furthest reaching point in the present diagonal\n\t\t\t\t// by looking at the diagonals above and below and picking the one whose point\n\t\t\t\t// is further away from the start point (originalEnd, modifiedEnd)\n\t\t\t\tif (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n\t\t\t\t\toriginalIndex = reversePoints[diagonal + 1] - 1;\n\t\t\t\t} else {\n\t\t\t\t\toriginalIndex = reversePoints[diagonal - 1];\n\t\t\t\t}\n\t\t\t\tmodifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n\n\t\t\t\t// Save the current originalIndex so we can test for false overlap\n\t\t\t\ttempOriginalIndex = originalIndex;\n\n\t\t\t\t// STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n\t\t\t\t// as long as the elements are equal.\n\t\t\t\twhile (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n\t\t\t\t\toriginalIndex--;\n\t\t\t\t\tmodifiedIndex--;\n\t\t\t\t}\n\t\t\t\treversePoints[diagonal] = originalIndex;\n\n\t\t\t\t// STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n\t\t\t\t// and diagonal is in the range of forward diagonals computed for numDifferences\n\t\t\t\t// then check for overlap.\n\t\t\t\tif (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n\t\t\t\t\tif (originalIndex <= forwardPoints[diagonal]) {\n\t\t\t\t\t\tmidOriginalArr[0] = originalIndex;\n\t\t\t\t\t\tmidModifiedArr[0] = modifiedIndex;\n\n\t\t\t\t\t\tif (tempOriginalIndex >= forwardPoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {\n\t\t\t\t\t\t\t// BINGO! We overlapped, and we have the full trace in memory!\n\t\t\t\t\t\t\treturn this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset,\n\t\t\t\t\t\t\t\tdiagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset,\n\t\t\t\t\t\t\t\tforwardPoints, reversePoints,\n\t\t\t\t\t\t\t\toriginalIndex, originalEnd, midOriginalArr,\n\t\t\t\t\t\t\t\tmodifiedIndex, modifiedEnd, midModifiedArr,\n\t\t\t\t\t\t\t\tdeltaIsEven, quitEarlyArr\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Either false overlap, or we didn't have enough memory for the full trace\n\t\t\t\t\t\t\t// Just return the recursion point\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Save current vectors to history before the next iteration\n\t\t\tif (numDifferences <= MaxDifferencesHistory) {\n\t\t\t\t// We are allocating space for one extra int, which we fill with\n\t\t\t\t// the index of the diagonal base index\n\t\t\t\tlet temp: number[] = new Array<number>(diagonalForwardEnd - diagonalForwardStart + 2);\n\t\t\t\ttemp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n\t\t\t\tMyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n\t\t\t\tthis.m_forwardHistory.push(temp);\n\n\t\t\t\ttemp = new Array<number>(diagonalReverseEnd - diagonalReverseStart + 2);\n\t\t\t\ttemp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n\t\t\t\tMyArray.Copy(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n\t\t\t\tthis.m_reverseHistory.push(temp);\n\t\t\t}\n\n\t\t}\n\n\n\n\t\t// If we got here, then we have the full trace in history. We just have to convert it to a change list\n\t\t// NOTE: This part is a bit messy\n\t\treturn this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset,\n\t\t\tdiagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset,\n\t\t\tforwardPoints, reversePoints,\n\t\t\toriginalIndex, originalEnd, midOriginalArr,\n\t\t\tmodifiedIndex, modifiedEnd, midModifiedArr,\n\t\t\tdeltaIsEven, quitEarlyArr\n\t\t);\n\t}\n\n\t/**\n\t * Shifts the given changes to provide a more intuitive diff.\n\t * While the first element in a diff matches the first element after the diff,\n\t * we shift the diff down.\n\t *\n\t * @param changes The list of changes to shift\n\t * @returns The shifted changes\n\t */\n\tprivate ShiftChanges(changes: DiffChange[]): DiffChange[] {\n\t\tlet mergedDiffs: boolean;\n\t\tdo {\n\t\t\tmergedDiffs = false;\n\n\t\t\t// Shift all the changes down first\n\t\t\tfor (let i = 0; i < changes.length; i++) {\n\t\t\t\tconst change = changes[i];\n\t\t\t\tconst originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this.OriginalSequence.getLength();\n\t\t\t\tconst modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this.ModifiedSequence.getLength();\n\t\t\t\tconst checkOriginal = change.originalLength > 0;\n\t\t\t\tconst checkModified = change.modifiedLength > 0;\n\n\t\t\t\twhile (change.originalStart + change.originalLength < originalStop &&\n\t\t\t\t\tchange.modifiedStart + change.modifiedLength < modifiedStop &&\n\t\t\t\t\t(!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength)) &&\n\t\t\t\t\t(!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n\t\t\t\t\tchange.originalStart++;\n\t\t\t\t\tchange.modifiedStart++;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Build up the new list (we have to build a new list because we\n\t\t\t// might have changes we can merge together now)\n\t\t\tlet result = new Array<DiffChange>();\n\t\t\tlet mergedChangeArr: DiffChange[] = [null];\n\t\t\tfor (let i = 0; i < changes.length; i++) {\n\t\t\t\tif (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n\t\t\t\t\tmergedDiffs = true;\n\t\t\t\t\tresult.push(mergedChangeArr[0]);\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tresult.push(changes[i]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tchanges = result;\n\t\t} while (mergedDiffs);\n\n\t\t// Shift changes back up until we hit empty or whitespace-only lines\n\t\tfor (let i = changes.length - 1; i >= 0; i--) {\n\t\t\tconst change = changes[i];\n\n\t\t\tlet originalStop = 0;\n\t\t\tlet modifiedStop = 0;\n\t\t\tif (i > 0) {\n\t\t\t\tconst prevChange = changes[i - 1];\n\t\t\t\tif (prevChange.originalLength > 0) {\n\t\t\t\t\toriginalStop = prevChange.originalStart + prevChange.originalLength;\n\t\t\t\t}\n\t\t\t\tif (prevChange.modifiedLength > 0) {\n\t\t\t\t\tmodifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst checkOriginal = change.originalLength > 0;\n\t\t\tconst checkModified = change.modifiedLength > 0;\n\n\t\t\tlet bestDelta = 0;\n\t\t\tlet bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n\n\t\t\tfor (let delta = 1; ; delta++) {\n\t\t\t\tlet originalStart = change.originalStart - delta;\n\t\t\t\tlet modifiedStart = change.modifiedStart - delta;\n\n\t\t\t\tif (originalStart < originalStop || modifiedStart < modifiedStop) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tlet score = this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength);\n\n\t\t\t\tif (score > bestScore) {\n\t\t\t\t\tbestScore = score;\n\t\t\t\t\tbestDelta = delta;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tchange.originalStart -= bestDelta;\n\t\t\tchange.modifiedStart -= bestDelta;\n\t\t}\n\n\t\treturn changes;\n\t}\n\n\tprivate _OriginalIsBoundary(index: number): boolean {\n\t\tif (index <= 0 || index >= this.OriginalSequence.getLength() - 1) {\n\t\t\treturn true;\n\t\t}\n\t\treturn /^\\s*$/.test(this.OriginalSequence.getElementHash(index));\n\t}\n\n\tprivate _OriginalRegionIsBoundary(originalStart: number, originalLength: number): boolean {\n\t\tif (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n\t\t\treturn true;\n\t\t}\n\t\tif (originalLength > 0) {\n\t\t\tlet originalEnd = originalStart + originalLength;\n\t\t\tif (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\tprivate _ModifiedIsBoundary(index: number): boolean {\n\t\tif (index <= 0 || index >= this.ModifiedSequence.getLength() - 1) {\n\t\t\treturn true;\n\t\t}\n\t\treturn /^\\s*$/.test(this.ModifiedSequence.getElementHash(index));\n\t}\n\n\tprivate _ModifiedRegionIsBoundary(modifiedStart: number, modifiedLength: number): boolean {\n\t\tif (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n\t\t\treturn true;\n\t\t}\n\t\tif (modifiedLength > 0) {\n\t\t\tlet modifiedEnd = modifiedStart + modifiedLength;\n\t\t\tif (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\tprivate _boundaryScore(originalStart: number, originalLength: number, modifiedStart: number, modifiedLength: number): number {\n\t\tlet originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n\t\tlet modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n\t\treturn (originalScore + modifiedScore);\n\t}\n\n\t/**\n\t * Concatenates the two input DiffChange lists and returns the resulting\n\t * list.\n\t * @param The left changes\n\t * @param The right changes\n\t * @returns The concatenated list\n\t */\n\tprivate ConcatenateChanges(left: DiffChange[], right: DiffChange[]): DiffChange[] {\n\t\tlet mergedChangeArr: DiffChange[] = [];\n\t\tlet result: DiffChange[] = null;\n\n\t\tif (left.length === 0 || right.length === 0) {\n\t\t\treturn (right.length > 0) ? right : left;\n\t\t} else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n\t\t\t// Since we break the problem down recursively, it is possible that we\n\t\t\t// might recurse in the middle of a change thereby splitting it into\n\t\t\t// two changes. Here in the combining stage, we detect and fuse those\n\t\t\t// changes back together\n\t\t\tresult = new Array<DiffChange>(left.length + right.length - 1);\n\t\t\tMyArray.Copy(left, 0, result, 0, left.length - 1);\n\t\t\tresult[left.length - 1] = mergedChangeArr[0];\n\t\t\tMyArray.Copy(right, 1, result, left.length, right.length - 1);\n\n\t\t\treturn result;\n\t\t} else {\n\t\t\tresult = new Array<DiffChange>(left.length + right.length);\n\t\t\tMyArray.Copy(left, 0, result, 0, left.length);\n\t\t\tMyArray.Copy(right, 0, result, left.length, right.length);\n\n\t\t\treturn result;\n\t\t}\n\t}\n\n\t/**\n\t * Returns true if the two changes overlap and can be merged into a single\n\t * change\n\t * @param left The left change\n\t * @param right The right change\n\t * @param mergedChange The merged change if the two overlap, null otherwise\n\t * @returns True if the two changes overlap\n\t */\n\tprivate ChangesOverlap(left: DiffChange, right: DiffChange, mergedChangeArr: DiffChange[]): boolean {\n\t\tDebug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n\t\tDebug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n\n\t\tif (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n\t\t\tlet originalStart = left.originalStart;\n\t\t\tlet originalLength = left.originalLength;\n\t\t\tlet modifiedStart = left.modifiedStart;\n\t\t\tlet modifiedLength = left.modifiedLength;\n\n\t\t\tif (left.originalStart + left.originalLength >= right.originalStart) {\n\t\t\t\toriginalLength = right.originalStart + right.originalLength - left.originalStart;\n\t\t\t}\n\t\t\tif (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n\t\t\t\tmodifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n\t\t\t}\n\n\t\t\tmergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n\t\t\treturn true;\n\t\t} else {\n\t\t\tmergedChangeArr[0] = null;\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Helper method used to clip a diagonal index to the range of valid\n\t * diagonals. This also decides whether or not the diagonal index,\n\t * if it exceeds the boundary, should be clipped to the boundary or clipped\n\t * one inside the boundary depending on the Even/Odd status of the boundary\n\t * and numDifferences.\n\t * @param diagonal The index of the diagonal to clip.\n\t * @param numDifferences The current number of differences being iterated upon.\n\t * @param diagonalBaseIndex The base reference diagonal.\n\t * @param numDiagonals The total number of diagonals.\n\t * @returns The clipped diagonal index.\n\t */\n\tprivate ClipDiagonalBound(diagonal: number, numDifferences: number, diagonalBaseIndex: number, numDiagonals: number): number {\n\t\tif (diagonal >= 0 && diagonal < numDiagonals) {\n\t\t\t// Nothing to clip, its in range\n\t\t\treturn diagonal;\n\t\t}\n\n\t\t// diagonalsBelow: The number of diagonals below the reference diagonal\n\t\t// diagonalsAbove: The number of diagonals above the reference diagonal\n\t\tlet diagonalsBelow = diagonalBaseIndex;\n\t\tlet diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n\t\tlet diffEven = (numDifferences % 2 === 0);\n\n\t\tif (diagonal < 0) {\n\t\t\tlet lowerBoundEven = (diagonalsBelow % 2 === 0);\n\t\t\treturn (diffEven === lowerBoundEven) ? 0 : 1;\n\t\t} else {\n\t\t\tlet upperBoundEven = (diagonalsAbove % 2 === 0);\n\t\t\treturn (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n\t\t}\n\t}\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'use strict';\n\nexport function once<T extends Function>(this: any, fn: T): T {\n\tconst _this = this;\n\tlet didCall = false;\n\tlet result: any;\n\n\treturn function () {\n\t\tif (didCall) {\n\t\t\treturn result;\n\t\t}\n\n\t\tdidCall = true;\n\t\tresult = fn.apply(_this, arguments);\n\n\t\treturn result;\n\t} as any as T;\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'use strict';\n\nimport { OperatingSystem } from 'vs/base/common/platform';\n\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 const enum KeyCode {\n\t/**\n\t * Placed first to cover the 0 value of the enum.\n\t */\n\tUnknown = 0,\n\n\tBackspace = 1,\n\tTab = 2,\n\tEnter = 3,\n\tShift = 4,\n\tCtrl = 5,\n\tAlt = 6,\n\tPauseBreak = 7,\n\tCapsLock = 8,\n\tEscape = 9,\n\tSpace = 10,\n\tPageUp = 11,\n\tPageDown = 12,\n\tEnd = 13,\n\tHome = 14,\n\tLeftArrow = 15,\n\tUpArrow = 16,\n\tRightArrow = 17,\n\tDownArrow = 18,\n\tInsert = 19,\n\tDelete = 20,\n\n\tKEY_0 = 21,\n\tKEY_1 = 22,\n\tKEY_2 = 23,\n\tKEY_3 = 24,\n\tKEY_4 = 25,\n\tKEY_5 = 26,\n\tKEY_6 = 27,\n\tKEY_7 = 28,\n\tKEY_8 = 29,\n\tKEY_9 = 30,\n\n\tKEY_A = 31,\n\tKEY_B = 32,\n\tKEY_C = 33,\n\tKEY_D = 34,\n\tKEY_E = 35,\n\tKEY_F = 36,\n\tKEY_G = 37,\n\tKEY_H = 38,\n\tKEY_I = 39,\n\tKEY_J = 40,\n\tKEY_K = 41,\n\tKEY_L = 42,\n\tKEY_M = 43,\n\tKEY_N = 44,\n\tKEY_O = 45,\n\tKEY_P = 46,\n\tKEY_Q = 47,\n\tKEY_R = 48,\n\tKEY_S = 49,\n\tKEY_T = 50,\n\tKEY_U = 51,\n\tKEY_V = 52,\n\tKEY_W = 53,\n\tKEY_X = 54,\n\tKEY_Y = 55,\n\tKEY_Z = 56,\n\n\tMeta = 57,\n\tContextMenu = 58,\n\n\tF1 = 59,\n\tF2 = 60,\n\tF3 = 61,\n\tF4 = 62,\n\tF5 = 63,\n\tF6 = 64,\n\tF7 = 65,\n\tF8 = 66,\n\tF9 = 67,\n\tF10 = 68,\n\tF11 = 69,\n\tF12 = 70,\n\tF13 = 71,\n\tF14 = 72,\n\tF15 = 73,\n\tF16 = 74,\n\tF17 = 75,\n\tF18 = 76,\n\tF19 = 77,\n\n\tNumLock = 78,\n\tScrollLock = 79,\n\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ';:' key\n\t */\n\tUS_SEMICOLON = 80,\n\t/**\n\t * For any country/region, the '+' key\n\t * For the US standard keyboard, the '=+' key\n\t */\n\tUS_EQUAL = 81,\n\t/**\n\t * For any country/region, the ',' key\n\t * For the US standard keyboard, the ',<' key\n\t */\n\tUS_COMMA = 82,\n\t/**\n\t * For any country/region, the '-' key\n\t * For the US standard keyboard, the '-_' key\n\t */\n\tUS_MINUS = 83,\n\t/**\n\t * For any country/region, the '.' key\n\t * For the US standard keyboard, the '.>' key\n\t */\n\tUS_DOT = 84,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '/?' key\n\t */\n\tUS_SLASH = 85,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '`~' key\n\t */\n\tUS_BACKTICK = 86,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '[{' key\n\t */\n\tUS_OPEN_SQUARE_BRACKET = 87,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '\\|' key\n\t */\n\tUS_BACKSLASH = 88,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ']}' key\n\t */\n\tUS_CLOSE_SQUARE_BRACKET = 89,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ''\"' key\n\t */\n\tUS_QUOTE = 90,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t */\n\tOEM_8 = 91,\n\t/**\n\t * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n\t */\n\tOEM_102 = 92,\n\n\tNUMPAD_0 = 93, // VK_NUMPAD0, 0x60, Numeric keypad 0 key\n\tNUMPAD_1 = 94, // VK_NUMPAD1, 0x61, Numeric keypad 1 key\n\tNUMPAD_2 = 95, // VK_NUMPAD2, 0x62, Numeric keypad 2 key\n\tNUMPAD_3 = 96, // VK_NUMPAD3, 0x63, Numeric keypad 3 key\n\tNUMPAD_4 = 97, // VK_NUMPAD4, 0x64, Numeric keypad 4 key\n\tNUMPAD_5 = 98, // VK_NUMPAD5, 0x65, Numeric keypad 5 key\n\tNUMPAD_6 = 99, // VK_NUMPAD6, 0x66, Numeric keypad 6 key\n\tNUMPAD_7 = 100, // VK_NUMPAD7, 0x67, Numeric keypad 7 key\n\tNUMPAD_8 = 101, // VK_NUMPAD8, 0x68, Numeric keypad 8 key\n\tNUMPAD_9 = 102, // VK_NUMPAD9, 0x69, Numeric keypad 9 key\n\n\tNUMPAD_MULTIPLY = 103,\t// VK_MULTIPLY, 0x6A, Multiply key\n\tNUMPAD_ADD = 104,\t\t// VK_ADD, 0x6B, Add key\n\tNUMPAD_SEPARATOR = 105,\t// VK_SEPARATOR, 0x6C, Separator key\n\tNUMPAD_SUBTRACT = 106,\t// VK_SUBTRACT, 0x6D, Subtract key\n\tNUMPAD_DECIMAL = 107,\t// VK_DECIMAL, 0x6E, Decimal key\n\tNUMPAD_DIVIDE = 108,\t// VK_DIVIDE, 0x6F,\n\n\t/**\n\t * Cover all key codes when IME is processing input.\n\t */\n\tKEY_IN_COMPOSITION = 109,\n\n\tABNT_C1 = 110, // Brazilian (ABNT) Keyboard\n\tABNT_C2 = 111, // Brazilian (ABNT) Keyboard\n\n\t/**\n\t * Placed last to cover the length of the enum.\n\t * Please do not depend on this value!\n\t */\n\tMAX_VALUE\n}\n\nclass KeyCodeStrMap {\n\n\tprivate _keyCodeToStr: string[];\n\tprivate _strToKeyCode: { [str: string]: KeyCode; };\n\n\tconstructor() {\n\t\tthis._keyCodeToStr = [];\n\t\tthis._strToKeyCode = Object.create(null);\n\t}\n\n\tdefine(keyCode: KeyCode, str: string): void {\n\t\tthis._keyCodeToStr[keyCode] = str;\n\t\tthis._strToKeyCode[str.toLowerCase()] = keyCode;\n\t}\n\n\tkeyCodeToStr(keyCode: KeyCode): string {\n\t\treturn this._keyCodeToStr[keyCode];\n\t}\n\n\tstrToKeyCode(str: string): KeyCode {\n\t\treturn this._strToKeyCode[str.toLowerCase()] || KeyCode.Unknown;\n\t}\n}\n\nconst uiMap = new KeyCodeStrMap();\nconst userSettingsUSMap = new KeyCodeStrMap();\nconst userSettingsGeneralMap = new KeyCodeStrMap();\n\n(function () {\n\n\tfunction define(keyCode: KeyCode, uiLabel: string, usUserSettingsLabel: string = uiLabel, generalUserSettingsLabel: string = usUserSettingsLabel): void {\n\t\tuiMap.define(keyCode, uiLabel);\n\t\tuserSettingsUSMap.define(keyCode, usUserSettingsLabel);\n\t\tuserSettingsGeneralMap.define(keyCode, generalUserSettingsLabel);\n\t}\n\n\tdefine(KeyCode.Unknown, 'unknown');\n\n\tdefine(KeyCode.Backspace, 'Backspace');\n\tdefine(KeyCode.Tab, 'Tab');\n\tdefine(KeyCode.Enter, 'Enter');\n\tdefine(KeyCode.Shift, 'Shift');\n\tdefine(KeyCode.Ctrl, 'Ctrl');\n\tdefine(KeyCode.Alt, 'Alt');\n\tdefine(KeyCode.PauseBreak, 'PauseBreak');\n\tdefine(KeyCode.CapsLock, 'CapsLock');\n\tdefine(KeyCode.Escape, 'Escape');\n\tdefine(KeyCode.Space, 'Space');\n\tdefine(KeyCode.PageUp, 'PageUp');\n\tdefine(KeyCode.PageDown, 'PageDown');\n\tdefine(KeyCode.End, 'End');\n\tdefine(KeyCode.Home, 'Home');\n\n\tdefine(KeyCode.LeftArrow, 'LeftArrow', 'Left');\n\tdefine(KeyCode.UpArrow, 'UpArrow', 'Up');\n\tdefine(KeyCode.RightArrow, 'RightArrow', 'Right');\n\tdefine(KeyCode.DownArrow, 'DownArrow', 'Down');\n\tdefine(KeyCode.Insert, 'Insert');\n\tdefine(KeyCode.Delete, 'Delete');\n\n\tdefine(KeyCode.KEY_0, '0');\n\tdefine(KeyCode.KEY_1, '1');\n\tdefine(KeyCode.KEY_2, '2');\n\tdefine(KeyCode.KEY_3, '3');\n\tdefine(KeyCode.KEY_4, '4');\n\tdefine(KeyCode.KEY_5, '5');\n\tdefine(KeyCode.KEY_6, '6');\n\tdefine(KeyCode.KEY_7, '7');\n\tdefine(KeyCode.KEY_8, '8');\n\tdefine(KeyCode.KEY_9, '9');\n\n\tdefine(KeyCode.KEY_A, 'A');\n\tdefine(KeyCode.KEY_B, 'B');\n\tdefine(KeyCode.KEY_C, 'C');\n\tdefine(KeyCode.KEY_D, 'D');\n\tdefine(KeyCode.KEY_E, 'E');\n\tdefine(KeyCode.KEY_F, 'F');\n\tdefine(KeyCode.KEY_G, 'G');\n\tdefine(KeyCode.KEY_H, 'H');\n\tdefine(KeyCode.KEY_I, 'I');\n\tdefine(KeyCode.KEY_J, 'J');\n\tdefine(KeyCode.KEY_K, 'K');\n\tdefine(KeyCode.KEY_L, 'L');\n\tdefine(KeyCode.KEY_M, 'M');\n\tdefine(KeyCode.KEY_N, 'N');\n\tdefine(KeyCode.KEY_O, 'O');\n\tdefine(KeyCode.KEY_P, 'P');\n\tdefine(KeyCode.KEY_Q, 'Q');\n\tdefine(KeyCode.KEY_R, 'R');\n\tdefine(KeyCode.KEY_S, 'S');\n\tdefine(KeyCode.KEY_T, 'T');\n\tdefine(KeyCode.KEY_U, 'U');\n\tdefine(KeyCode.KEY_V, 'V');\n\tdefine(KeyCode.KEY_W, 'W');\n\tdefine(KeyCode.KEY_X, 'X');\n\tdefine(KeyCode.KEY_Y, 'Y');\n\tdefine(KeyCode.KEY_Z, 'Z');\n\n\tdefine(KeyCode.Meta, 'Meta');\n\tdefine(KeyCode.ContextMenu, 'ContextMenu');\n\n\tdefine(KeyCode.F1, 'F1');\n\tdefine(KeyCode.F2, 'F2');\n\tdefine(KeyCode.F3, 'F3');\n\tdefine(KeyCode.F4, 'F4');\n\tdefine(KeyCode.F5, 'F5');\n\tdefine(KeyCode.F6, 'F6');\n\tdefine(KeyCode.F7, 'F7');\n\tdefine(KeyCode.F8, 'F8');\n\tdefine(KeyCode.F9, 'F9');\n\tdefine(KeyCode.F10, 'F10');\n\tdefine(KeyCode.F11, 'F11');\n\tdefine(KeyCode.F12, 'F12');\n\tdefine(KeyCode.F13, 'F13');\n\tdefine(KeyCode.F14, 'F14');\n\tdefine(KeyCode.F15, 'F15');\n\tdefine(KeyCode.F16, 'F16');\n\tdefine(KeyCode.F17, 'F17');\n\tdefine(KeyCode.F18, 'F18');\n\tdefine(KeyCode.F19, 'F19');\n\n\tdefine(KeyCode.NumLock, 'NumLock');\n\tdefine(KeyCode.ScrollLock, 'ScrollLock');\n\n\tdefine(KeyCode.US_SEMICOLON, ';', ';', 'OEM_1');\n\tdefine(KeyCode.US_EQUAL, '=', '=', 'OEM_PLUS');\n\tdefine(KeyCode.US_COMMA, ',', ',', 'OEM_COMMA');\n\tdefine(KeyCode.US_MINUS, '-', '-', 'OEM_MINUS');\n\tdefine(KeyCode.US_DOT, '.', '.', 'OEM_PERIOD');\n\tdefine(KeyCode.US_SLASH, '/', '/', 'OEM_2');\n\tdefine(KeyCode.US_BACKTICK, '`', '`', 'OEM_3');\n\tdefine(KeyCode.ABNT_C1, 'ABNT_C1');\n\tdefine(KeyCode.ABNT_C2, 'ABNT_C2');\n\tdefine(KeyCode.US_OPEN_SQUARE_BRACKET, '[', '[', 'OEM_4');\n\tdefine(KeyCode.US_BACKSLASH, '\\\\', '\\\\', 'OEM_5');\n\tdefine(KeyCode.US_CLOSE_SQUARE_BRACKET, ']', ']', 'OEM_6');\n\tdefine(KeyCode.US_QUOTE, '\\'', '\\'', 'OEM_7');\n\tdefine(KeyCode.OEM_8, 'OEM_8');\n\tdefine(KeyCode.OEM_102, 'OEM_102');\n\n\tdefine(KeyCode.NUMPAD_0, 'NumPad0');\n\tdefine(KeyCode.NUMPAD_1, 'NumPad1');\n\tdefine(KeyCode.NUMPAD_2, 'NumPad2');\n\tdefine(KeyCode.NUMPAD_3, 'NumPad3');\n\tdefine(KeyCode.NUMPAD_4, 'NumPad4');\n\tdefine(KeyCode.NUMPAD_5, 'NumPad5');\n\tdefine(KeyCode.NUMPAD_6, 'NumPad6');\n\tdefine(KeyCode.NUMPAD_7, 'NumPad7');\n\tdefine(KeyCode.NUMPAD_8, 'NumPad8');\n\tdefine(KeyCode.NUMPAD_9, 'NumPad9');\n\n\tdefine(KeyCode.NUMPAD_MULTIPLY, 'NumPad_Multiply');\n\tdefine(KeyCode.NUMPAD_ADD, 'NumPad_Add');\n\tdefine(KeyCode.NUMPAD_SEPARATOR, 'NumPad_Separator');\n\tdefine(KeyCode.NUMPAD_SUBTRACT, 'NumPad_Subtract');\n\tdefine(KeyCode.NUMPAD_DECIMAL, 'NumPad_Decimal');\n\tdefine(KeyCode.NUMPAD_DIVIDE, 'NumPad_Divide');\n\n})();\n\nexport namespace KeyCodeUtils {\n\texport function toString(keyCode: KeyCode): string {\n\t\treturn uiMap.keyCodeToStr(keyCode);\n\t}\n\texport function fromString(key: string): KeyCode {\n\t\treturn uiMap.strToKeyCode(key);\n\t}\n\n\texport function toUserSettingsUS(keyCode: KeyCode): string {\n\t\treturn userSettingsUSMap.keyCodeToStr(keyCode);\n\t}\n\texport function toUserSettingsGeneral(keyCode: KeyCode): string {\n\t\treturn userSettingsGeneralMap.keyCodeToStr(keyCode);\n\t}\n\texport function fromUserSettings(key: string): KeyCode {\n\t\treturn userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n\t}\n}\n\n/**\n * Binary encoding strategy:\n * ```\n * 1111 11\n * 5432 1098 7654 3210\n * ---- CSAW KKKK KKKK\n * C = bit 11 = ctrlCmd flag\n * S = bit 10 = shift flag\n * A = bit 9 = alt flag\n * W = bit 8 = winCtrl flag\n * K = bits 0-7 = key code\n * ```\n */\nconst enum BinaryKeybindingsMask {\n\tCtrlCmd = (1 << 11) >>> 0,\n\tShift = (1 << 10) >>> 0,\n\tAlt = (1 << 9) >>> 0,\n\tWinCtrl = (1 << 8) >>> 0,\n\tKeyCode = 0x000000ff\n}\n\nexport const enum KeyMod {\n\tCtrlCmd = (1 << 11) >>> 0,\n\tShift = (1 << 10) >>> 0,\n\tAlt = (1 << 9) >>> 0,\n\tWinCtrl = (1 << 8) >>> 0,\n}\n\nexport function KeyChord(firstPart: number, secondPart: number): number {\n\tlet chordPart = ((secondPart & 0x0000ffff) << 16) >>> 0;\n\treturn (firstPart | chordPart) >>> 0;\n}\n\nexport function createKeybinding(keybinding: number, OS: OperatingSystem): Keybinding {\n\tif (keybinding === 0) {\n\t\treturn null;\n\t}\n\tconst firstPart = (keybinding & 0x0000ffff) >>> 0;\n\tconst chordPart = (keybinding & 0xffff0000) >>> 16;\n\tif (chordPart !== 0) {\n\t\treturn new ChordKeybinding(\n\t\t\tcreateSimpleKeybinding(firstPart, OS),\n\t\t\tcreateSimpleKeybinding(chordPart, OS),\n\t\t);\n\t}\n\treturn createSimpleKeybinding(firstPart, OS);\n}\n\nexport function createSimpleKeybinding(keybinding: number, OS: OperatingSystem): SimpleKeybinding {\n\n\tconst ctrlCmd = (keybinding & BinaryKeybindingsMask.CtrlCmd ? true : false);\n\tconst winCtrl = (keybinding & BinaryKeybindingsMask.WinCtrl ? true : false);\n\n\tconst ctrlKey = (OS === OperatingSystem.Macintosh ? winCtrl : ctrlCmd);\n\tconst shiftKey = (keybinding & BinaryKeybindingsMask.Shift ? true : false);\n\tconst altKey = (keybinding & BinaryKeybindingsMask.Alt ? true : false);\n\tconst metaKey = (OS === OperatingSystem.Macintosh ? ctrlCmd : winCtrl);\n\tconst keyCode = (keybinding & BinaryKeybindingsMask.KeyCode);\n\n\treturn new SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode);\n}\n\nexport const enum KeybindingType {\n\tSimple = 1,\n\tChord = 2\n}\n\nexport class SimpleKeybinding {\n\tpublic readonly type = KeybindingType.Simple;\n\n\tpublic readonly ctrlKey: boolean;\n\tpublic readonly shiftKey: boolean;\n\tpublic readonly altKey: boolean;\n\tpublic readonly metaKey: boolean;\n\tpublic readonly keyCode: KeyCode;\n\n\tconstructor(ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean, keyCode: KeyCode) {\n\t\tthis.ctrlKey = ctrlKey;\n\t\tthis.shiftKey = shiftKey;\n\t\tthis.altKey = altKey;\n\t\tthis.metaKey = metaKey;\n\t\tthis.keyCode = keyCode;\n\t}\n\n\tpublic equals(other: Keybinding): boolean {\n\t\tif (other.type !== KeybindingType.Simple) {\n\t\t\treturn false;\n\t\t}\n\t\treturn (\n\t\t\tthis.ctrlKey === other.ctrlKey\n\t\t\t&& this.shiftKey === other.shiftKey\n\t\t\t&& this.altKey === other.altKey\n\t\t\t&& this.metaKey === other.metaKey\n\t\t\t&& this.keyCode === other.keyCode\n\t\t);\n\t}\n\n\tpublic getHashCode(): string {\n\t\tlet ctrl = this.ctrlKey ? '1' : '0';\n\t\tlet shift = this.shiftKey ? '1' : '0';\n\t\tlet alt = this.altKey ? '1' : '0';\n\t\tlet meta = this.metaKey ? '1' : '0';\n\t\treturn `${ctrl}${shift}${alt}${meta}${this.keyCode}`;\n\t}\n\n\tpublic isModifierKey(): boolean {\n\t\treturn (\n\t\t\tthis.keyCode === KeyCode.Unknown\n\t\t\t|| this.keyCode === KeyCode.Ctrl\n\t\t\t|| this.keyCode === KeyCode.Meta\n\t\t\t|| this.keyCode === KeyCode.Alt\n\t\t\t|| this.keyCode === KeyCode.Shift\n\t\t);\n\t}\n\n\t/**\n\t * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?\n\t */\n\tpublic isDuplicateModifierCase(): boolean {\n\t\treturn (\n\t\t\t(this.ctrlKey && this.keyCode === KeyCode.Ctrl)\n\t\t\t|| (this.shiftKey && this.keyCode === KeyCode.Shift)\n\t\t\t|| (this.altKey && this.keyCode === KeyCode.Alt)\n\t\t\t|| (this.metaKey && this.keyCode === KeyCode.Meta)\n\t\t);\n\t}\n}\n\nexport class ChordKeybinding {\n\tpublic readonly type = KeybindingType.Chord;\n\n\tpublic readonly firstPart: SimpleKeybinding;\n\tpublic readonly chordPart: SimpleKeybinding;\n\n\tconstructor(firstPart: SimpleKeybinding, chordPart: SimpleKeybinding) {\n\t\tthis.firstPart = firstPart;\n\t\tthis.chordPart = chordPart;\n\t}\n\n\tpublic getHashCode(): string {\n\t\treturn `${this.firstPart.getHashCode()};${this.chordPart.getHashCode()}`;\n\t}\n}\n\nexport type Keybinding = SimpleKeybinding | ChordKeybinding;\n\nexport class ResolvedKeybindingPart {\n\treadonly ctrlKey: boolean;\n\treadonly shiftKey: boolean;\n\treadonly altKey: boolean;\n\treadonly metaKey: boolean;\n\n\treadonly keyLabel: string;\n\treadonly keyAriaLabel: string;\n\n\tconstructor(ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean, kbLabel: string, kbAriaLabel: string) {\n\t\tthis.ctrlKey = ctrlKey;\n\t\tthis.shiftKey = shiftKey;\n\t\tthis.altKey = altKey;\n\t\tthis.metaKey = metaKey;\n\t\tthis.keyLabel = kbLabel;\n\t\tthis.keyAriaLabel = kbAriaLabel;\n\t}\n}\n\n/**\n * A resolved keybinding. Can be a simple keybinding or a chord keybinding.\n */\nexport abstract class ResolvedKeybinding {\n\t/**\n\t * This prints the binding in a format suitable for displaying in the UI.\n\t */\n\tpublic abstract getLabel(): string;\n\t/**\n\t * This prints the binding in a format suitable for ARIA.\n\t */\n\tpublic abstract getAriaLabel(): string;\n\t/**\n\t * This prints the binding in a format suitable for electron's accelerators.\n\t * See https://github.com/electron/electron/blob/master/docs/api/accelerator.md\n\t */\n\tpublic abstract getElectronAccelerator(): string;\n\t/**\n\t * This prints the binding in a format suitable for user settings.\n\t */\n\tpublic abstract getUserSettingsLabel(): string;\n\t/**\n\t * Is the user settings label reflecting the label?\n\t */\n\tpublic abstract isWYSIWYG(): boolean;\n\n\t/**\n\t * Is the binding a chord?\n\t */\n\tpublic abstract isChord(): boolean;\n\n\t/**\n\t * Returns the firstPart, chordPart that should be used for dispatching.\n\t */\n\tpublic abstract getDispatchParts(): [string, string];\n\t/**\n\t * Returns the firstPart, chordPart of the keybinding.\n\t * For simple keybindings, the second element will be null.\n\t */\n\tpublic abstract getParts(): [ResolvedKeybindingPart, ResolvedKeybindingPart];\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'use strict';\n\nimport { once } from 'vs/base/common/functional';\n\nexport const empty: IDisposable = Object.freeze<IDisposable>({\n\tdispose() { }\n});\n\nexport interface IDisposable {\n\tdispose(): void;\n}\n\nexport function isDisposable<E extends object>(thing: E): thing is E & IDisposable {\n\treturn typeof (<IDisposable><any>thing).dispose === 'function'\n\t\t&& (<IDisposable><any>thing).dispose.length === 0;\n}\n\nexport function dispose<T extends IDisposable>(disposable: T): T;\nexport function dispose<T extends IDisposable>(...disposables: T[]): T[];\nexport function dispose<T extends IDisposable>(disposables: T[]): T[];\nexport function dispose<T extends IDisposable>(first: T | T[], ...rest: T[]): T | T[] {\n\n\tif (Array.isArray(first)) {\n\t\tfirst.forEach(d => d && d.dispose());\n\t\treturn [];\n\t} else if (rest.length === 0) {\n\t\tif (first) {\n\t\t\tfirst.dispose();\n\t\t\treturn first;\n\t\t}\n\t\treturn undefined;\n\t} else {\n\t\tdispose(first);\n\t\tdispose(rest);\n\t\treturn [];\n\t}\n}\n\nexport function combinedDisposable(disposables: IDisposable[]): IDisposable {\n\treturn { dispose: () => dispose(disposables) };\n}\n\nexport function toDisposable(...fns: (() => void)[]): IDisposable {\n\treturn {\n\t\tdispose() {\n\t\t\tfor (const fn of fns) {\n\t\t\t\tfn();\n\t\t\t}\n\t\t}\n\t};\n}\n\nexport abstract class Disposable implements IDisposable {\n\n\tprivate _toDispose: IDisposable[];\n\n\tconstructor() {\n\t\tthis._toDispose = [];\n\t}\n\n\tpublic dispose(): void {\n\t\tthis._toDispose = dispose(this._toDispose);\n\t}\n\n\tprotected _register<T extends IDisposable>(t: T): T {\n\t\tthis._toDispose.push(t);\n\t\treturn t;\n\t}\n}\n\nexport interface IReference<T> extends IDisposable {\n\treadonly object: T;\n}\n\nexport abstract class ReferenceCollection<T> {\n\n\tprivate references: { [key: string]: { readonly object: T; counter: number; } } = Object.create(null);\n\n\tconstructor() { }\n\n\tacquire(key: string): IReference<T> {\n\t\tlet reference = this.references[key];\n\n\t\tif (!reference) {\n\t\t\treference = this.references[key] = { counter: 0, object: this.createReferencedObject(key) };\n\t\t}\n\n\t\tconst { object } = reference;\n\t\tconst dispose = once(() => {\n\t\t\tif (--reference.counter === 0) {\n\t\t\t\tthis.destroyReferencedObject(reference.object);\n\t\t\t\tdelete this.references[key];\n\t\t\t}\n\t\t});\n\n\t\treference.counter++;\n\n\t\treturn { object, dispose };\n\t}\n\n\tprotected abstract createReferencedObject(key: string): T;\n\tprotected abstract destroyReferencedObject(object: T): void;\n}\n\nexport class ImmortalReference<T> implements IReference<T> {\n\tconstructor(public object: T) { }\n\tdispose(): void { /* noop */ }\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'use strict';\n\nimport { IIterator } from 'vs/base/common/iterator';\n\nclass Node<E> {\n\telement: E;\n\tnext: Node<E>;\n\tprev: Node<E>;\n\n\tconstructor(element: E) {\n\t\tthis.element = element;\n\t}\n}\n\nexport class LinkedList<E> {\n\n\tprivate _first: Node<E>;\n\tprivate _last: Node<E>;\n\n\tisEmpty(): boolean {\n\t\treturn !this._first;\n\t}\n\n\tclear(): void {\n\t\tthis._first = undefined;\n\t\tthis._last = undefined;\n\t}\n\n\tunshift(element: E) {\n\t\treturn this.insert(element, false);\n\t}\n\n\tpush(element: E) {\n\t\treturn this.insert(element, true);\n\t}\n\n\tprivate insert(element: E, atTheEnd: boolean) {\n\t\tconst newNode = new Node(element);\n\t\tif (!this._first) {\n\t\t\tthis._first = newNode;\n\t\t\tthis._last = newNode;\n\n\t\t} else if (atTheEnd) {\n\t\t\t// push\n\t\t\tconst oldLast = this._last;\n\t\t\tthis._last = newNode;\n\t\t\tnewNode.prev = oldLast;\n\t\t\toldLast.next = newNode;\n\n\t\t} else {\n\t\t\t// unshift\n\t\t\tconst oldFirst = this._first;\n\t\t\tthis._first = newNode;\n\t\t\tnewNode.next = oldFirst;\n\t\t\toldFirst.prev = newNode;\n\t\t}\n\n\t\treturn () => {\n\n\t\t\tfor (let candidate = this._first; candidate instanceof Node; candidate = candidate.next) {\n\t\t\t\tif (candidate !== newNode) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (candidate.prev && candidate.next) {\n\t\t\t\t\t// middle\n\t\t\t\t\tlet anchor = candidate.prev;\n\t\t\t\t\tanchor.next = candidate.next;\n\t\t\t\t\tcandidate.next.prev = anchor;\n\n\t\t\t\t} else if (!candidate.prev && !candidate.next) {\n\t\t\t\t\t// only node\n\t\t\t\t\tthis._first = undefined;\n\t\t\t\t\tthis._last = undefined;\n\n\t\t\t\t} else if (!candidate.next) {\n\t\t\t\t\t// last\n\t\t\t\t\tthis._last = this._last.prev;\n\t\t\t\t\tthis._last.next = undefined;\n\n\t\t\t\t} else if (!candidate.prev) {\n\t\t\t\t\t// first\n\t\t\t\t\tthis._first = this._first.next;\n\t\t\t\t\tthis._first.prev = undefined;\n\t\t\t\t}\n\n\t\t\t\t// done\n\t\t\t\tbreak;\n\t\t\t}\n\t\t};\n\t}\n\n\titerator(): IIterator<E> {\n\t\tlet element = {\n\t\t\tdone: undefined,\n\t\t\tvalue: undefined,\n\t\t};\n\t\tlet node = this._first;\n\t\treturn {\n\t\t\tnext(): { done: boolean; value: E } {\n\t\t\t\tif (!node) {\n\t\t\t\t\telement.done = true;\n\t\t\t\t\telement.value = undefined;\n\t\t\t\t} else {\n\t\t\t\t\telement.done = false;\n\t\t\t\t\telement.value = node.element;\n\t\t\t\t\tnode = node.next;\n\t\t\t\t}\n\t\t\t\treturn element;\n\t\t\t}\n\t\t};\n\t}\n\n\ttoArray(): E[] {\n\t\tlet result: E[] = [];\n\t\tfor (let node = this._first; node instanceof Node; node = node.next) {\n\t\t\tresult.push(node.element);\n\t\t}\n\t\treturn result;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nlet _isWindows = false;\nlet _isMacintosh = false;\nlet _isLinux = false;\nlet _isNative = false;\nlet _isWeb = false;\nlet _locale: string = undefined;\nlet _language: string = undefined;\nlet _translationsConfigFile: string = undefined;\n\ninterface NLSConfig {\n\tlocale: string;\n\tavailableLanguages: { [key: string]: string; };\n\t_translationsConfigFile: string;\n}\n\nexport interface IProcessEnvironment {\n\t[key: string]: string;\n}\n\ninterface INodeProcess {\n\tplatform: string;\n\tenv: IProcessEnvironment;\n\tgetuid(): number;\n\tnextTick: Function;\n}\ndeclare let process: INodeProcess;\ndeclare let global: any;\n\ninterface INavigator {\n\tuserAgent: string;\n\tlanguage: string;\n}\ndeclare let navigator: INavigator;\ndeclare let self: any;\n\nexport const LANGUAGE_DEFAULT = 'en';\n\n// OS detection\nif (typeof process === 'object' && typeof process.nextTick === 'function' && typeof process.platform === 'string') {\n\t_isWindows = (process.platform === 'win32');\n\t_isMacintosh = (process.platform === 'darwin');\n\t_isLinux = (process.platform === 'linux');\n\tconst rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];\n\tif (rawNlsConfig) {\n\t\ttry {\n\t\t\tconst nlsConfig: NLSConfig = JSON.parse(rawNlsConfig);\n\t\t\tconst resolved = nlsConfig.availableLanguages['*'];\n\t\t\t_locale = nlsConfig.locale;\n\t\t\t// VSCode's default language is 'en'\n\t\t\t_language = resolved ? resolved : LANGUAGE_DEFAULT;\n\t\t\t_translationsConfigFile = nlsConfig._translationsConfigFile;\n\t\t} catch (e) {\n\t\t}\n\t}\n\t_isNative = true;\n} else if (typeof navigator === 'object') {\n\tconst userAgent = navigator.userAgent;\n\t_isWindows = userAgent.indexOf('Windows') >= 0;\n\t_isMacintosh = userAgent.indexOf('Macintosh') >= 0;\n\t_isLinux = userAgent.indexOf('Linux') >= 0;\n\t_isWeb = true;\n\t_locale = navigator.language;\n\t_language = _locale;\n}\n\nexport enum Platform {\n\tWeb,\n\tMac,\n\tLinux,\n\tWindows\n}\n\nlet _platform: Platform = Platform.Web;\nif (_isNative) {\n\tif (_isMacintosh) {\n\t\t_platform = Platform.Mac;\n\t} else if (_isWindows) {\n\t\t_platform = Platform.Windows;\n\t} else if (_isLinux) {\n\t\t_platform = Platform.Linux;\n\t}\n}\n\nexport const isWindows = _isWindows;\nexport const isMacintosh = _isMacintosh;\nexport const isLinux = _isLinux;\nexport const isNative = _isNative;\nexport const isWeb = _isWeb;\nexport const platform = _platform;\n\nexport function isRootUser(): boolean {\n\treturn _isNative && !_isWindows && (process.getuid() === 0);\n}\n\n/**\n * The language used for the user interface. The format of\n * the string is all lower case (e.g. zh-tw for Traditional\n * Chinese)\n */\nexport const language = _language;\n\n/**\n * The OS locale or the locale specified by --locale. The format of\n * the string is all lower case (e.g. zh-tw for Traditional\n * Chinese). The UI is not necessarily shown in the provided locale.\n */\nexport const locale = _locale;\n\n/**\n * The translatios that are available through language packs.\n */\nexport const translationsConfigFile = _translationsConfigFile;\n\nconst _globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {} as any);\nexport const globals: any = _globals;\n\nlet _setImmediate: (callback: (...args: any[]) => void) => number = null;\nexport function setImmediate(callback: (...args: any[]) => void): number {\n\tif (_setImmediate === null) {\n\t\tif (globals.setImmediate) {\n\t\t\t_setImmediate = globals.setImmediate.bind(globals);\n\t\t} else if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {\n\t\t\t_setImmediate = process.nextTick.bind(process);\n\t\t} else {\n\t\t\t_setImmediate = globals.setTimeout.bind(globals);\n\t\t}\n\t}\n\treturn _setImmediate(callback);\n}\n\nexport const enum OperatingSystem {\n\tWindows = 1,\n\tMacintosh = 2,\n\tLinux = 3\n}\nexport const OS = (_isMacintosh ? OperatingSystem.Macintosh : (_isWindows ? OperatingSystem.Windows : OperatingSystem.Linux));\n\nexport const enum AccessibilitySupport {\n\t/**\n\t * This should be the browser case where it is not known if a screen reader is attached or no.\n\t */\n\tUnknown = 0,\n\n\tDisabled = 1,\n\n\tEnabled = 2\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport * as platform from 'vs/base/common/platform';\n\n\nfunction _encode(ch: string): string {\n\treturn '%' + ch.charCodeAt(0).toString(16).toUpperCase();\n}\n\n// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\nfunction encodeURIComponent2(str: string): string {\n\treturn encodeURIComponent(str).replace(/[!'()*]/g, _encode);\n}\n\nfunction encodeNoop(str: string): string {\n\treturn str.replace(/[#?]/, _encode);\n}\n\n\nconst _schemePattern = /^\\w[\\w\\d+.-]*$/;\nconst _singleSlashStart = /^\\//;\nconst _doubleSlashStart = /^\\/\\//;\n\nfunction _validateUri(ret: URI): void {\n\t// scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n\t// ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n\tif (ret.scheme && !_schemePattern.test(ret.scheme)) {\n\t\tthrow new Error('[UriError]: Scheme contains illegal characters.');\n\t}\n\n\t// path, http://tools.ietf.org/html/rfc3986#section-3.3\n\t// If a URI contains an authority component, then the path component\n\t// must either be empty or begin with a slash (\"/\") character. If a URI\n\t// does not contain an authority component, then the path cannot begin\n\t// with two slash characters (\"//\").\n\tif (ret.path) {\n\t\tif (ret.authority) {\n\t\t\tif (!_singleSlashStart.test(ret.path)) {\n\t\t\t\tthrow 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\t\t\t}\n\t\t} else {\n\t\t\tif (_doubleSlashStart.test(ret.path)) {\n\t\t\t\tthrow new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n\t\t\t}\n\t\t}\n\t}\n}\n\nconst _empty = '';\nconst _slash = '/';\nconst _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\nconst _driveLetterPath = /^\\/[a-zA-Z]:/;\nconst _upperCaseDrive = /^(\\/)?([A-Z]:)/;\nconst _driveLetter = /^[a-zA-Z]:/;\n\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component paths\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n * foo://example.com:8042/over/there?name=ferret#nose\n * \\_/ \\______________/\\_________/ \\_________/ \\__/\n * | | | | |\n * scheme authority path query fragment\n * | _____________________|__\n * / \\ / \\\n * urn:example:animal:ferret:nose\n *\n *\n */\nexport default class URI implements UriComponents {\n\n\tstatic isUri(thing: any): thing is URI {\n\t\tif (thing instanceof URI) {\n\t\t\treturn true;\n\t\t}\n\t\tif (!thing) {\n\t\t\treturn false;\n\t\t}\n\t\treturn typeof (<URI>thing).authority === 'string'\n\t\t\t&& typeof (<URI>thing).fragment === 'string'\n\t\t\t&& typeof (<URI>thing).path === 'string'\n\t\t\t&& typeof (<URI>thing).query === 'string'\n\t\t\t&& typeof (<URI>thing).scheme === 'string';\n\t}\n\n\t/**\n\t * scheme is the 'http' part of 'http://www.msft.com/some/path?query#fragment'.\n\t * The part before the first colon.\n\t */\n\treadonly scheme: string;\n\n\t/**\n\t * authority is the 'www.msft.com' part of 'http://www.msft.com/some/path?query#fragment'.\n\t * The part between the first double slashes and the next slash.\n\t */\n\treadonly authority: string;\n\n\t/**\n\t * path is the '/some/path' part of 'http://www.msft.com/some/path?query#fragment'.\n\t */\n\treadonly path: string;\n\n\t/**\n\t * query is the 'query' part of 'http://www.msft.com/some/path?query#fragment'.\n\t */\n\treadonly query: string;\n\n\t/**\n\t * fragment is the 'fragment' part of 'http://www.msft.com/some/path?query#fragment'.\n\t */\n\treadonly fragment: string;\n\n\t/**\n\t * @internal\n\t */\n\tprotected constructor(scheme: string, authority: string, path: string, query: string, fragment: string);\n\n\t/**\n\t * @internal\n\t */\n\tprotected constructor(components: UriComponents);\n\n\t/**\n\t * @internal\n\t */\n\tprotected constructor(schemeOrData: string | UriComponents, authority?: string, path?: string, query?: string, fragment?: string) {\n\n\t\tif (typeof schemeOrData === 'object') {\n\t\t\tthis.scheme = schemeOrData.scheme || _empty;\n\t\t\tthis.authority = schemeOrData.authority || _empty;\n\t\t\tthis.path = schemeOrData.path || _empty;\n\t\t\tthis.query = schemeOrData.query || _empty;\n\t\t\tthis.fragment = schemeOrData.fragment || _empty;\n\t\t\t// no validation because it's this URI\n\t\t\t// that creates uri components.\n\t\t\t// _validateUri(this);\n\t\t} else {\n\t\t\tthis.scheme = schemeOrData || _empty;\n\t\t\tthis.authority = authority || _empty;\n\t\t\tthis.path = path || _empty;\n\t\t\tthis.query = query || _empty;\n\t\t\tthis.fragment = fragment || _empty;\n\t\t\t_validateUri(this);\n\t\t}\n\t}\n\n\t// ---- filesystem path -----------------------\n\n\t/**\n\t * Returns a string representing the corresponding file system path of this URI.\n\t * Will handle UNC paths and normalize windows drive letters to lower-case. Also\n\t * uses the platform specific path separator. Will *not* validate the path for\n\t * invalid characters and semantics. Will *not* look at the scheme of this URI.\n\t */\n\tget fsPath(): string {\n\t\treturn _makeFsPath(this);\n\t}\n\n\t// ---- modify to new -------------------------\n\n\tpublic with(change: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {\n\n\t\tif (!change) {\n\t\t\treturn this;\n\t\t}\n\n\t\tlet { scheme, authority, path, query, fragment } = change;\n\t\tif (scheme === void 0) {\n\t\t\tscheme = this.scheme;\n\t\t} else if (scheme === null) {\n\t\t\tscheme = _empty;\n\t\t}\n\t\tif (authority === void 0) {\n\t\t\tauthority = this.authority;\n\t\t} else if (authority === null) {\n\t\t\tauthority = _empty;\n\t\t}\n\t\tif (path === void 0) {\n\t\t\tpath = this.path;\n\t\t} else if (path === null) {\n\t\t\tpath = _empty;\n\t\t}\n\t\tif (query === void 0) {\n\t\t\tquery = this.query;\n\t\t} else if (query === null) {\n\t\t\tquery = _empty;\n\t\t}\n\t\tif (fragment === void 0) {\n\t\t\tfragment = this.fragment;\n\t\t} else if (fragment === null) {\n\t\t\tfragment = _empty;\n\t\t}\n\n\t\tif (scheme === this.scheme\n\t\t\t&& authority === this.authority\n\t\t\t&& path === this.path\n\t\t\t&& query === this.query\n\t\t\t&& fragment === this.fragment) {\n\n\t\t\treturn this;\n\t\t}\n\n\t\treturn new _URI(scheme, authority, path, query, fragment);\n\t}\n\n\t// ---- parse & validate ------------------------\n\n\tpublic static parse(value: string): URI {\n\t\tconst match = _regexp.exec(value);\n\t\tif (!match) {\n\t\t\treturn new _URI(_empty, _empty, _empty, _empty, _empty);\n\t\t}\n\t\treturn new _URI(\n\t\t\tmatch[2] || _empty,\n\t\t\tdecodeURIComponent(match[4] || _empty),\n\t\t\tdecodeURIComponent(match[5] || _empty),\n\t\t\tdecodeURIComponent(match[7] || _empty),\n\t\t\tdecodeURIComponent(match[9] || _empty),\n\t\t);\n\t}\n\n\tpublic static file(path: string): URI {\n\n\t\tlet authority = _empty;\n\n\t\t// normalize to fwd-slashes on windows,\n\t\t// on other systems bwd-slashes are valid\n\t\t// filename character, eg /f\\oo/ba\\r.txt\n\t\tif (platform.isWindows) {\n\t\t\tpath = path.replace(/\\\\/g, _slash);\n\t\t}\n\n\t\t// check for authority as used in UNC shares\n\t\t// or use the path as given\n\t\tif (path[0] === _slash && path[1] === _slash) {\n\t\t\tlet idx = path.indexOf(_slash, 2);\n\t\t\tif (idx === -1) {\n\t\t\t\tauthority = path.substring(2);\n\t\t\t\tpath = _slash;\n\t\t\t} else {\n\t\t\t\tauthority = path.substring(2, idx);\n\t\t\t\tpath = path.substring(idx) || _slash;\n\t\t\t}\n\t\t}\n\n\t\t// Ensure that path starts with a slash\n\t\t// or that it is at least a slash\n\t\tif (_driveLetter.test(path)) {\n\t\t\tpath = _slash + path;\n\n\t\t} else if (path[0] !== _slash) {\n\t\t\t// tricky -> makes invalid paths\n\t\t\t// but otherwise we have to stop\n\t\t\t// allowing relative paths...\n\t\t\tpath = _slash + path;\n\t\t}\n\n\t\treturn new _URI('file', authority, path, _empty, _empty);\n\t}\n\n\tpublic static from(components: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {\n\t\treturn new _URI(\n\t\t\tcomponents.scheme,\n\t\t\tcomponents.authority,\n\t\t\tcomponents.path,\n\t\t\tcomponents.query,\n\t\t\tcomponents.fragment,\n\t\t);\n\t}\n\n\t// ---- printing/externalize ---------------------------\n\n\t/**\n\t *\n\t * @param skipEncoding Do not encode the result, default is `false`\n\t */\n\tpublic toString(skipEncoding: boolean = false): string {\n\t\treturn _asFormatted(this, skipEncoding);\n\t}\n\n\tpublic toJSON(): object {\n\t\tconst res = <UriState>{\n\t\t\t$mid: 1,\n\t\t\tfsPath: this.fsPath,\n\t\t\texternal: this.toString(),\n\t\t};\n\n\t\tif (this.path) {\n\t\t\tres.path = this.path;\n\t\t}\n\n\t\tif (this.scheme) {\n\t\t\tres.scheme = this.scheme;\n\t\t}\n\n\t\tif (this.authority) {\n\t\t\tres.authority = this.authority;\n\t\t}\n\n\t\tif (this.query) {\n\t\t\tres.query = this.query;\n\t\t}\n\n\t\tif (this.fragment) {\n\t\t\tres.fragment = this.fragment;\n\t\t}\n\n\t\treturn res;\n\t}\n\n\tstatic revive(data: UriComponents | any): URI {\n\t\tif (!data) {\n\t\t\treturn data;\n\t\t} else if (data instanceof URI) {\n\t\t\treturn data;\n\t\t} else {\n\t\t\tlet result = new _URI(data);\n\t\t\tresult._fsPath = (<UriState>data).fsPath;\n\t\t\tresult._formatted = (<UriState>data).external;\n\t\t\treturn result;\n\t\t}\n\t}\n}\n\nexport interface UriComponents {\n\tscheme: string;\n\tauthority: string;\n\tpath: string;\n\tquery: string;\n\tfragment: string;\n}\n\ninterface UriState extends UriComponents {\n\t$mid: number;\n\tfsPath: string;\n\texternal: string;\n}\n\n\n// tslint:disable-next-line:class-name\nclass _URI extends URI {\n\n\t_formatted: string = null;\n\t_fsPath: string = null;\n\n\tget fsPath(): string {\n\t\tif (!this._fsPath) {\n\t\t\tthis._fsPath = _makeFsPath(this);\n\t\t}\n\t\treturn this._fsPath;\n\t}\n\n\tpublic toString(skipEncoding: boolean = false): string {\n\t\tif (!skipEncoding) {\n\t\t\tif (!this._formatted) {\n\t\t\t\tthis._formatted = _asFormatted(this, false);\n\t\t\t}\n\t\t\treturn this._formatted;\n\t\t} else {\n\t\t\t// we don't cache that\n\t\t\treturn _asFormatted(this, true);\n\t\t}\n\t}\n}\n\n\n/**\n * Compute `fsPath` for the given uri\n * @param uri\n */\nfunction _makeFsPath(uri: URI): string {\n\n\tlet value: string;\n\tif (uri.authority && uri.path && uri.scheme === 'file') {\n\t\t// unc path: file://shares/c$/far/boo\n\t\tvalue = `//${uri.authority}${uri.path}`;\n\t} else if (_driveLetterPath.test(uri.path)) {\n\t\t// windows drive letter: file:///c:/far/boo\n\t\tvalue = uri.path[1].toLowerCase() + uri.path.substr(2);\n\t} else {\n\t\t// other path\n\t\tvalue = uri.path;\n\t}\n\tif (platform.isWindows) {\n\t\tvalue = value.replace(/\\//g, '\\\\');\n\t}\n\treturn value;\n}\n\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri: URI, skipEncoding: boolean): string {\n\n\tconst encoder = !skipEncoding\n\t\t? encodeURIComponent2\n\t\t: encodeNoop;\n\n\tconst parts: string[] = [];\n\n\tlet { scheme, authority, path, query, fragment } = uri;\n\tif (scheme) {\n\t\tparts.push(scheme, ':');\n\t}\n\tif (authority || scheme === 'file') {\n\t\tparts.push('//');\n\t}\n\tif (authority) {\n\t\tlet idx = authority.indexOf('@');\n\t\tif (idx !== -1) {\n\t\t\tconst userinfo = authority.substr(0, idx);\n\t\t\tauthority = authority.substr(idx + 1);\n\t\t\tidx = userinfo.indexOf(':');\n\t\t\tif (idx === -1) {\n\t\t\t\tparts.push(encoder(userinfo));\n\t\t\t} else {\n\t\t\t\tparts.push(encoder(userinfo.substr(0, idx)), ':', encoder(userinfo.substr(idx + 1)));\n\t\t\t}\n\t\t\tparts.push('@');\n\t\t}\n\t\tauthority = authority.toLowerCase();\n\t\tidx = authority.indexOf(':');\n\t\tif (idx === -1) {\n\t\t\tparts.push(encoder(authority));\n\t\t} else {\n\t\t\tparts.push(encoder(authority.substr(0, idx)), authority.substr(idx));\n\t\t}\n\t}\n\tif (path) {\n\t\t// lower-case windows drive letters in /C:/fff or C:/fff\n\t\tconst m = _upperCaseDrive.exec(path);\n\t\tif (m) {\n\t\t\tif (m[1]) {\n\t\t\t\tpath = '/' + m[2].toLowerCase() + path.substr(3); // \"/c:\".length === 3\n\t\t\t} else {\n\t\t\t\tpath = m[2].toLowerCase() + path.substr(2); // // \"c:\".length === 2\n\t\t\t}\n\t\t}\n\n\t\t// encode every segement but not slashes\n\t\t// make sure that # and ? are always encoded\n\t\t// when occurring in paths - otherwise the result\n\t\t// cannot be parsed back again\n\t\tlet lastIdx = 0;\n\t\twhile (true) {\n\t\t\tlet idx = path.indexOf(_slash, lastIdx);\n\t\t\tif (idx === -1) {\n\t\t\t\tparts.push(encoder(path.substring(lastIdx)));\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tparts.push(encoder(path.substring(lastIdx, idx)), _slash);\n\t\t\tlastIdx = idx + 1;\n\t\t}\n\t}\n\tif (query) {\n\t\tparts.push('?', encoder(query));\n\t}\n\tif (fragment) {\n\t\tparts.push('#', encoder(fragment));\n\t}\n\n\treturn parts.join(_empty);\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'use strict';\n\nimport URI from 'vs/base/common/uri';\n\nexport function values<V = any>(set: Set<V>): V[];\nexport function values<K = any, V = any>(map: Map<K, V>): V[];\nexport function values<V>(forEachable: { forEach(callback: (value: V, ...more: any[]) => any) }): V[] {\n\tconst result: V[] = [];\n\tforEachable.forEach(value => result.push(value));\n\treturn result;\n}\n\nexport function keys<K, V>(map: Map<K, V>): K[] {\n\tconst result: K[] = [];\n\tmap.forEach((value, key) => result.push(key));\n\n\treturn result;\n}\n\nexport function getOrSet<K, V>(map: Map<K, V>, key: K, value: V): V {\n\tlet result = map.get(key);\n\tif (result === void 0) {\n\t\tresult = value;\n\t\tmap.set(key, result);\n\t}\n\n\treturn result;\n}\n\nexport interface IKeyIterator {\n\treset(key: string): this;\n\tnext(): this;\n\tjoin(parts: string[]): string;\n\n\thasNext(): boolean;\n\tcmp(a: string): number;\n\tvalue(): string;\n}\n\nexport class StringIterator implements IKeyIterator {\n\n\tprivate _value: string = '';\n\tprivate _pos: number = 0;\n\n\treset(key: string): this {\n\t\tthis._value = key;\n\t\tthis._pos = 0;\n\t\treturn this;\n\t}\n\n\tnext(): this {\n\t\tthis._pos += 1;\n\t\treturn this;\n\t}\n\n\tjoin(parts: string[]): string {\n\t\treturn parts.join('');\n\t}\n\n\thasNext(): boolean {\n\t\treturn this._pos < this._value.length - 1;\n\t}\n\n\tcmp(a: string): number {\n\t\tlet aCode = a.charCodeAt(0);\n\t\tlet thisCode = this._value.charCodeAt(this._pos);\n\t\treturn aCode - thisCode;\n\t}\n\n\tvalue(): string {\n\t\treturn this._value[this._pos];\n\t}\n}\n\nexport class PathIterator implements IKeyIterator {\n\n\tprivate static readonly _fwd = '/'.charCodeAt(0);\n\tprivate static readonly _bwd = '\\\\'.charCodeAt(0);\n\n\tprivate _value: string;\n\tprivate _from: number;\n\tprivate _to: number;\n\n\treset(key: string): this {\n\t\tthis._value = key.replace(/\\\\$|\\/$/, '');\n\t\tthis._from = 0;\n\t\tthis._to = 0;\n\t\treturn this.next();\n\t}\n\n\thasNext(): boolean {\n\t\treturn this._to < this._value.length;\n\t}\n\n\tjoin(parts: string[]): string {\n\t\treturn parts.join('/');\n\t}\n\n\tnext(): this {\n\t\t// this._data = key.split(/[\\\\/]/).filter(s => !!s);\n\t\tthis._from = this._to;\n\t\tlet justSeps = true;\n\t\tfor (; this._to < this._value.length; this._to++) {\n\t\t\tconst ch = this._value.charCodeAt(this._to);\n\t\t\tif (ch === PathIterator._fwd || ch === PathIterator._bwd) {\n\t\t\t\tif (justSeps) {\n\t\t\t\t\tthis._from++;\n\t\t\t\t} else {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tjustSeps = false;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\tcmp(a: string): number {\n\n\t\tlet aPos = 0;\n\t\tlet aLen = a.length;\n\t\tlet thisPos = this._from;\n\n\t\twhile (aPos < aLen && thisPos < this._to) {\n\t\t\tlet cmp = a.charCodeAt(aPos) - this._value.charCodeAt(thisPos);\n\t\t\tif (cmp !== 0) {\n\t\t\t\treturn cmp;\n\t\t\t}\n\t\t\taPos += 1;\n\t\t\tthisPos += 1;\n\t\t}\n\n\t\tif (aLen === this._to - this._from) {\n\t\t\treturn 0;\n\t\t} else if (aPos < aLen) {\n\t\t\treturn -1;\n\t\t} else {\n\t\t\treturn 1;\n\t\t}\n\t}\n\n\tvalue(): string {\n\t\treturn this._value.substring(this._from, this._to);\n\t}\n}\n\nclass TernarySearchTreeNode<E> {\n\tstr: string;\n\telement: E;\n\tleft: TernarySearchTreeNode<E>;\n\tmid: TernarySearchTreeNode<E>;\n\tright: TernarySearchTreeNode<E>;\n\n\tisEmpty(): boolean {\n\t\treturn !this.left && !this.mid && !this.right && !this.element;\n\t}\n}\n\nexport class TernarySearchTree<E> {\n\n\tstatic forPaths<E>(): TernarySearchTree<E> {\n\t\treturn new TernarySearchTree<E>(new PathIterator());\n\t}\n\n\tstatic forStrings<E>(): TernarySearchTree<E> {\n\t\treturn new TernarySearchTree<E>(new StringIterator());\n\t}\n\n\tprivate _iter: IKeyIterator;\n\tprivate _root: TernarySearchTreeNode<E>;\n\n\tconstructor(segments: IKeyIterator) {\n\t\tthis._iter = segments;\n\t}\n\n\tclear(): void {\n\t\tthis._root = undefined;\n\t}\n\n\tset(key: string, element: E): E {\n\t\tlet iter = this._iter.reset(key);\n\t\tlet node: TernarySearchTreeNode<E>;\n\n\t\tif (!this._root) {\n\t\t\tthis._root = new TernarySearchTreeNode<E>();\n\t\t\tthis._root.str = iter.value();\n\t\t}\n\n\t\tnode = this._root;\n\t\twhile (true) {\n\t\t\tlet val = iter.cmp(node.str);\n\t\t\tif (val > 0) {\n\t\t\t\t// left\n\t\t\t\tif (!node.left) {\n\t\t\t\t\tnode.left = new TernarySearchTreeNode<E>();\n\t\t\t\t\tnode.left.str = iter.value();\n\t\t\t\t}\n\t\t\t\tnode = node.left;\n\n\t\t\t} else if (val < 0) {\n\t\t\t\t// right\n\t\t\t\tif (!node.right) {\n\t\t\t\t\tnode.right = new TernarySearchTreeNode<E>();\n\t\t\t\t\tnode.right.str = iter.value();\n\t\t\t\t}\n\t\t\t\tnode = node.right;\n\n\t\t\t} else if (iter.hasNext()) {\n\t\t\t\t// mid\n\t\t\t\titer.next();\n\t\t\t\tif (!node.mid) {\n\t\t\t\t\tnode.mid = new TernarySearchTreeNode<E>();\n\t\t\t\t\tnode.mid.str = iter.value();\n\t\t\t\t}\n\t\t\t\tnode = node.mid;\n\t\t\t} else {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tconst oldElement = node.element;\n\t\tnode.element = element;\n\t\treturn oldElement;\n\t}\n\n\tget(key: string): E {\n\t\tlet iter = this._iter.reset(key);\n\t\tlet node = this._root;\n\t\twhile (node) {\n\t\t\tlet val = iter.cmp(node.str);\n\t\t\tif (val > 0) {\n\t\t\t\t// left\n\t\t\t\tnode = node.left;\n\t\t\t} else if (val < 0) {\n\t\t\t\t// right\n\t\t\t\tnode = node.right;\n\t\t\t} else if (iter.hasNext()) {\n\t\t\t\t// mid\n\t\t\t\titer.next();\n\t\t\t\tnode = node.mid;\n\t\t\t} else {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn node ? node.element : undefined;\n\t}\n\n\tdelete(key: string): void {\n\n\t\tlet iter = this._iter.reset(key);\n\t\tlet stack: [-1 | 0 | 1, TernarySearchTreeNode<E>][] = [];\n\t\tlet node = this._root;\n\n\t\t// find and unset node\n\t\twhile (node) {\n\t\t\tlet val = iter.cmp(node.str);\n\t\t\tif (val > 0) {\n\t\t\t\t// left\n\t\t\t\tstack.push([1, node]);\n\t\t\t\tnode = node.left;\n\t\t\t} else if (val < 0) {\n\t\t\t\t// right\n\t\t\t\tstack.push([-1, node]);\n\t\t\t\tnode = node.right;\n\t\t\t} else if (iter.hasNext()) {\n\t\t\t\t// mid\n\t\t\t\titer.next();\n\t\t\t\tstack.push([0, node]);\n\t\t\t\tnode = node.mid;\n\t\t\t} else {\n\t\t\t\t// remove element\n\t\t\t\tnode.element = undefined;\n\n\t\t\t\t// clean up empty nodes\n\t\t\t\twhile (stack.length > 0 && node.isEmpty()) {\n\t\t\t\t\tlet [dir, parent] = stack.pop();\n\t\t\t\t\tswitch (dir) {\n\t\t\t\t\t\tcase 1: parent.left = undefined; break;\n\t\t\t\t\t\tcase 0: parent.mid = undefined; break;\n\t\t\t\t\t\tcase -1: parent.right = undefined; break;\n\t\t\t\t\t}\n\t\t\t\t\tnode = parent;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tfindSubstr(key: string): E {\n\t\tlet iter = this._iter.reset(key);\n\t\tlet node = this._root;\n\t\tlet candidate: E;\n\t\twhile (node) {\n\t\t\tlet val = iter.cmp(node.str);\n\t\t\tif (val > 0) {\n\t\t\t\t// left\n\t\t\t\tnode = node.left;\n\t\t\t} else if (val < 0) {\n\t\t\t\t// right\n\t\t\t\tnode = node.right;\n\t\t\t} else if (iter.hasNext()) {\n\t\t\t\t// mid\n\t\t\t\titer.next();\n\t\t\t\tcandidate = node.element || candidate;\n\t\t\t\tnode = node.mid;\n\t\t\t} else {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn node && node.element || candidate;\n\t}\n\n\tfindSuperstr(key: string): TernarySearchTree<E> {\n\t\tlet iter = this._iter.reset(key);\n\t\tlet node = this._root;\n\t\twhile (node) {\n\t\t\tlet val = iter.cmp(node.str);\n\t\t\tif (val > 0) {\n\t\t\t\t// left\n\t\t\t\tnode = node.left;\n\t\t\t} else if (val < 0) {\n\t\t\t\t// right\n\t\t\t\tnode = node.right;\n\t\t\t} else if (iter.hasNext()) {\n\t\t\t\t// mid\n\t\t\t\titer.next();\n\t\t\t\tnode = node.mid;\n\t\t\t} else {\n\t\t\t\t// collect\n\t\t\t\tif (!node.mid) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\tlet ret = new TernarySearchTree<E>(this._iter);\n\t\t\t\tret._root = node.mid;\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t}\n\t\treturn undefined;\n\t}\n\n\tforEach(callback: (value: E, index: string) => any) {\n\t\tthis._forEach(this._root, [], callback);\n\t}\n\n\tprivate _forEach(node: TernarySearchTreeNode<E>, parts: string[], callback: (value: E, index: string) => any) {\n\t\tif (node) {\n\t\t\t// left\n\t\t\tthis._forEach(node.left, parts, callback);\n\n\t\t\t// node\n\t\t\tparts.push(node.str);\n\t\t\tif (node.element) {\n\t\t\t\tcallback(node.element, this._iter.join(parts));\n\t\t\t}\n\t\t\t// mid\n\t\t\tthis._forEach(node.mid, parts, callback);\n\t\t\tparts.pop();\n\n\t\t\t// right\n\t\t\tthis._forEach(node.right, parts, callback);\n\t\t}\n\t}\n}\n\nexport class ResourceMap<T> {\n\n\tprotected readonly map: Map<string, T>;\n\tprotected readonly ignoreCase?: boolean;\n\n\tconstructor() {\n\t\tthis.map = new Map<string, T>();\n\t\tthis.ignoreCase = false; // in the future this should be an uri-comparator\n\t}\n\n\tpublic set(resource: URI, value: T): void {\n\t\tthis.map.set(this.toKey(resource), value);\n\t}\n\n\tpublic get(resource: URI): T {\n\t\treturn this.map.get(this.toKey(resource));\n\t}\n\n\tpublic has(resource: URI): boolean {\n\t\treturn this.map.has(this.toKey(resource));\n\t}\n\n\tpublic get size(): number {\n\t\treturn this.map.size;\n\t}\n\n\tpublic clear(): void {\n\t\tthis.map.clear();\n\t}\n\n\tpublic delete(resource: URI): boolean {\n\t\treturn this.map.delete(this.toKey(resource));\n\t}\n\n\tpublic forEach(clb: (value: T) => void): void {\n\t\tthis.map.forEach(clb);\n\t}\n\n\tpublic values(): T[] {\n\t\treturn values(this.map);\n\t}\n\n\tprivate toKey(resource: URI): string {\n\t\tlet key = resource.toString();\n\t\tif (this.ignoreCase) {\n\t\t\tkey = key.toLowerCase();\n\t\t}\n\n\t\treturn key;\n\t}\n\n\tpublic keys(): URI[] {\n\t\treturn keys(this.map).map(URI.parse);\n\t}\n}\n\n// We should fold BoundedMap and LinkedMap. See https://github.com/Microsoft/vscode/issues/28496\n\ninterface Item<K, V> {\n\tprevious: Item<K, V> | undefined;\n\tnext: Item<K, V> | undefined;\n\tkey: K;\n\tvalue: V;\n}\n\nexport enum Touch {\n\tNone = 0,\n\tAsOld = 1,\n\tAsNew = 2\n}\n\nexport class LinkedMap<K, V> {\n\n\tprivate _map: Map<K, Item<K, V>>;\n\tprivate _head: Item<K, V> | undefined;\n\tprivate _tail: Item<K, V> | undefined;\n\tprivate _size: number;\n\n\tconstructor() {\n\t\tthis._map = new Map<K, Item<K, V>>();\n\t\tthis._head = undefined;\n\t\tthis._tail = undefined;\n\t\tthis._size = 0;\n\t}\n\n\tpublic clear(): void {\n\t\tthis._map.clear();\n\t\tthis._head = undefined;\n\t\tthis._tail = undefined;\n\t\tthis._size = 0;\n\t}\n\n\tpublic isEmpty(): boolean {\n\t\treturn !this._head && !this._tail;\n\t}\n\n\tpublic get size(): number {\n\t\treturn this._size;\n\t}\n\n\tpublic has(key: K): boolean {\n\t\treturn this._map.has(key);\n\t}\n\n\tpublic get(key: K, touch: Touch = Touch.None): V | undefined {\n\t\tconst item = this._map.get(key);\n\t\tif (!item) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (touch !== Touch.None) {\n\t\t\tthis.touch(item, touch);\n\t\t}\n\t\treturn item.value;\n\t}\n\n\tpublic set(key: K, value: V, touch: Touch = Touch.None): void {\n\t\tlet item = this._map.get(key);\n\t\tif (item) {\n\t\t\titem.value = value;\n\t\t\tif (touch !== Touch.None) {\n\t\t\t\tthis.touch(item, touch);\n\t\t\t}\n\t\t} else {\n\t\t\titem = { key, value, next: undefined, previous: undefined };\n\t\t\tswitch (touch) {\n\t\t\t\tcase Touch.None:\n\t\t\t\t\tthis.addItemLast(item);\n\t\t\t\t\tbreak;\n\t\t\t\tcase Touch.AsOld:\n\t\t\t\t\tthis.addItemFirst(item);\n\t\t\t\t\tbreak;\n\t\t\t\tcase Touch.AsNew:\n\t\t\t\t\tthis.addItemLast(item);\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tthis.addItemLast(item);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tthis._map.set(key, item);\n\t\t\tthis._size++;\n\t\t}\n\t}\n\n\tpublic delete(key: K): boolean {\n\t\treturn !!this.remove(key);\n\t}\n\n\tpublic remove(key: K): V | undefined {\n\t\tconst item = this._map.get(key);\n\t\tif (!item) {\n\t\t\treturn undefined;\n\t\t}\n\t\tthis._map.delete(key);\n\t\tthis.removeItem(item);\n\t\tthis._size--;\n\t\treturn item.value;\n\t}\n\n\tpublic shift(): V | undefined {\n\t\tif (!this._head && !this._tail) {\n\t\t\treturn undefined;\n\t\t}\n\t\tif (!this._head || !this._tail) {\n\t\t\tthrow new Error('Invalid list');\n\t\t}\n\t\tconst item = this._head;\n\t\tthis._map.delete(item.key);\n\t\tthis.removeItem(item);\n\t\tthis._size--;\n\t\treturn item.value;\n\t}\n\n\tpublic forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void {\n\t\tlet current = this._head;\n\t\twhile (current) {\n\t\t\tif (thisArg) {\n\t\t\t\tcallbackfn.bind(thisArg)(current.value, current.key, this);\n\t\t\t} else {\n\t\t\t\tcallbackfn(current.value, current.key, this);\n\t\t\t}\n\t\t\tcurrent = current.next;\n\t\t}\n\t}\n\n\tpublic values(): V[] {\n\t\tlet result: V[] = [];\n\t\tlet current = this._head;\n\t\twhile (current) {\n\t\t\tresult.push(current.value);\n\t\t\tcurrent = current.next;\n\t\t}\n\t\treturn result;\n\t}\n\n\tpublic keys(): K[] {\n\t\tlet result: K[] = [];\n\t\tlet current = this._head;\n\t\twhile (current) {\n\t\t\tresult.push(current.key);\n\t\t\tcurrent = current.next;\n\t\t}\n\t\treturn result;\n\t}\n\n\t/* VS Code / Monaco editor runs on es5 which has no Symbol.iterator\n\tpublic keys(): IterableIterator<K> {\n\t\tlet current = this._head;\n\t\tlet iterator: IterableIterator<K> = {\n\t\t\t[Symbol.iterator]() {\n\t\t\t\treturn iterator;\n\t\t\t},\n\t\t\tnext():IteratorResult<K> {\n\t\t\t\tif (current) {\n\t\t\t\t\tlet result = { value: current.key, done: false };\n\t\t\t\t\tcurrent = current.next;\n\t\t\t\t\treturn result;\n\t\t\t\t} else {\n\t\t\t\t\treturn { value: undefined, done: true };\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\treturn iterator;\n\t}\n\n\tpublic values(): IterableIterator<V> {\n\t\tlet current = this._head;\n\t\tlet iterator: IterableIterator<V> = {\n\t\t\t[Symbol.iterator]() {\n\t\t\t\treturn iterator;\n\t\t\t},\n\t\t\tnext():IteratorResult<V> {\n\t\t\t\tif (current) {\n\t\t\t\t\tlet result = { value: current.value, done: false };\n\t\t\t\t\tcurrent = current.next;\n\t\t\t\t\treturn result;\n\t\t\t\t} else {\n\t\t\t\t\treturn { value: undefined, done: true };\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\treturn iterator;\n\t}\n\t*/\n\n\tprotected trimOld(newSize: number) {\n\t\tif (newSize >= this.size) {\n\t\t\treturn;\n\t\t}\n\t\tif (newSize === 0) {\n\t\t\tthis.clear();\n\t\t\treturn;\n\t\t}\n\t\tlet current = this._head;\n\t\tlet currentSize = this.size;\n\t\twhile (current && currentSize > newSize) {\n\t\t\tthis._map.delete(current.key);\n\t\t\tcurrent = current.next;\n\t\t\tcurrentSize--;\n\t\t}\n\t\tthis._head = current;\n\t\tthis._size = currentSize;\n\t\tcurrent.previous = void 0;\n\t}\n\n\tprivate addItemFirst(item: Item<K, V>): void {\n\t\t// First time Insert\n\t\tif (!this._head && !this._tail) {\n\t\t\tthis._tail = item;\n\t\t} else if (!this._head) {\n\t\t\tthrow new Error('Invalid list');\n\t\t} else {\n\t\t\titem.next = this._head;\n\t\t\tthis._head.previous = item;\n\t\t}\n\t\tthis._head = item;\n\t}\n\n\tprivate addItemLast(item: Item<K, V>): void {\n\t\t// First time Insert\n\t\tif (!this._head && !this._tail) {\n\t\t\tthis._head = item;\n\t\t} else if (!this._tail) {\n\t\t\tthrow new Error('Invalid list');\n\t\t} else {\n\t\t\titem.previous = this._tail;\n\t\t\tthis._tail.next = item;\n\t\t}\n\t\tthis._tail = item;\n\t}\n\n\tprivate removeItem(item: Item<K, V>): void {\n\t\tif (item === this._head && item === this._tail) {\n\t\t\tthis._head = void 0;\n\t\t\tthis._tail = void 0;\n\t\t}\n\t\telse if (item === this._head) {\n\t\t\tthis._head = item.next;\n\t\t}\n\t\telse if (item === this._tail) {\n\t\t\tthis._tail = item.previous;\n\t\t}\n\t\telse {\n\t\t\tconst next = item.next;\n\t\t\tconst previous = item.previous;\n\t\t\tif (!next || !previous) {\n\t\t\t\tthrow new Error('Invalid list');\n\t\t\t}\n\t\t\tnext.previous = previous;\n\t\t\tprevious.next = next;\n\t\t}\n\t}\n\n\tprivate touch(item: Item<K, V>, touch: Touch): void {\n\t\tif (!this._head || !this._tail) {\n\t\t\tthrow new Error('Invalid list');\n\t\t}\n\t\tif ((touch !== Touch.AsOld && touch !== Touch.AsNew)) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (touch === Touch.AsOld) {\n\t\t\tif (item === this._head) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst next = item.next;\n\t\t\tconst previous = item.previous;\n\n\t\t\t// Unlink the item\n\t\t\tif (item === this._tail) {\n\t\t\t\t// previous must be defined since item was not head but is tail\n\t\t\t\t// So there are more than on item in the map\n\t\t\t\tprevious!.next = void 0;\n\t\t\t\tthis._tail = previous;\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Both next and previous are not undefined since item was neither head nor tail.\n\t\t\t\tnext!.previous = previous;\n\t\t\t\tprevious!.next = next;\n\t\t\t}\n\n\t\t\t// Insert the node at head\n\t\t\titem.previous = void 0;\n\t\t\titem.next = this._head;\n\t\t\tthis._head.previous = item;\n\t\t\tthis._head = item;\n\t\t} else if (touch === Touch.AsNew) {\n\t\t\tif (item === this._tail) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst next = item.next;\n\t\t\tconst previous = item.previous;\n\n\t\t\t// Unlink the item.\n\t\t\tif (item === this._head) {\n\t\t\t\t// next must be defined since item was not tail but is head\n\t\t\t\t// So there are more than on item in the map\n\t\t\t\tnext!.previous = void 0;\n\t\t\t\tthis._head = next;\n\t\t\t} else {\n\t\t\t\t// Both next and previous are not undefined since item was neither head nor tail.\n\t\t\t\tnext!.previous = previous;\n\t\t\t\tprevious!.next = next;\n\t\t\t}\n\t\t\titem.next = void 0;\n\t\t\titem.previous = this._tail;\n\t\t\tthis._tail.next = item;\n\t\t\tthis._tail = item;\n\t\t}\n\t}\n\n\tpublic toJSON(): [K, V][] {\n\t\tconst data: [K, V][] = [];\n\n\t\tthis.forEach((value, key) => {\n\t\t\tdata.push([key, value]);\n\t\t});\n\n\t\treturn data;\n\t}\n\n\tpublic fromJSON(data: [K, V][]): void {\n\t\tthis.clear();\n\n\t\tfor (const [key, value] of data) {\n\t\t\tthis.set(key, value);\n\t\t}\n\t}\n}\n\nexport class LRUCache<K, V> extends LinkedMap<K, V> {\n\n\tprivate _limit: number;\n\tprivate _ratio: number;\n\n\tconstructor(limit: number, ratio: number = 1) {\n\t\tsuper();\n\t\tthis._limit = limit;\n\t\tthis._ratio = Math.min(Math.max(0, ratio), 1);\n\t}\n\n\tpublic get limit(): number {\n\t\treturn this._limit;\n\t}\n\n\tpublic set limit(limit: number) {\n\t\tthis._limit = limit;\n\t\tthis.checkTrim();\n\t}\n\n\tpublic get ratio(): number {\n\t\treturn this._ratio;\n\t}\n\n\tpublic set ratio(ratio: number) {\n\t\tthis._ratio = Math.min(Math.max(0, ratio), 1);\n\t\tthis.checkTrim();\n\t}\n\n\tpublic get(key: K): V | undefined {\n\t\treturn super.get(key, Touch.AsNew);\n\t}\n\n\tpublic peek(key: K): V | undefined {\n\t\treturn super.get(key, Touch.None);\n\t}\n\n\tpublic set(key: K, value: V): void {\n\t\tsuper.set(key, value, Touch.AsNew);\n\t\tthis.checkTrim();\n\t}\n\n\tprivate checkTrim() {\n\t\tif (this.size > this._limit) {\n\t\t\tthis.trimOld(Math.round(this._limit * this._ratio));\n\t\t}\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { LRUCache } from 'vs/base/common/map';\nimport { CharCode } from 'vs/base/common/charCode';\n\n/**\n * The empty string.\n */\nexport const empty = '';\n\nexport function isFalsyOrWhitespace(str: string): boolean {\n\tif (!str || typeof str !== 'string') {\n\t\treturn true;\n\t}\n\treturn str.trim().length === 0;\n}\n\n/**\n * @returns the provided number with the given number of preceding zeros.\n */\nexport function pad(n: number, l: number, char: string = '0'): string {\n\tlet str = '' + n;\n\tlet r = [str];\n\n\tfor (let i = str.length; i < l; i++) {\n\t\tr.push(char);\n\t}\n\n\treturn r.reverse().join('');\n}\n\nconst _formatRegexp = /{(\\d+)}/g;\n\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: string, ...args: any[]): string {\n\tif (args.length === 0) {\n\t\treturn value;\n\t}\n\treturn value.replace(_formatRegexp, function (match, group) {\n\t\tlet idx = parseInt(group, 10);\n\t\treturn isNaN(idx) || idx < 0 || idx >= args.length ?\n\t\t\tmatch :\n\t\t\targs[idx];\n\t});\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: string): string {\n\treturn html.replace(/[<|>|&]/g, function (match) {\n\t\tswitch (match) {\n\t\t\tcase '<': return '<';\n\t\t\tcase '>': return '>';\n\t\t\tcase '&': return '&';\n\t\t\tdefault: return match;\n\t\t}\n\t});\n}\n\n/**\n * Escapes regular expression characters in a given string\n */\nexport function escapeRegExpCharacters(value: string): string {\n\treturn value.replace(/[\\-\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)\\#]/g, '\\\\$&');\n}\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: string, needle: string = ' '): string {\n\tlet trimmed = ltrim(haystack, needle);\n\treturn rtrim(trimmed, needle);\n}\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?: string, needle?: string): string {\n\tif (!haystack || !needle) {\n\t\treturn haystack;\n\t}\n\n\tlet needleLen = needle.length;\n\tif (needleLen === 0 || haystack.length === 0) {\n\t\treturn haystack;\n\t}\n\n\tlet offset = 0,\n\t\tidx = -1;\n\n\twhile ((idx = haystack.indexOf(needle, offset)) === offset) {\n\t\toffset = offset + needleLen;\n\t}\n\treturn haystack.substring(offset);\n}\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?: string, needle?: string): string {\n\tif (!haystack || !needle) {\n\t\treturn haystack;\n\t}\n\n\tlet needleLen = needle.length,\n\t\thaystackLen = haystack.length;\n\n\tif (needleLen === 0 || haystackLen === 0) {\n\t\treturn haystack;\n\t}\n\n\tlet offset = haystackLen,\n\t\tidx = -1;\n\n\twhile (true) {\n\t\tidx = haystack.lastIndexOf(needle, offset - 1);\n\t\tif (idx === -1 || idx + needleLen !== offset) {\n\t\t\tbreak;\n\t\t}\n\t\tif (idx === 0) {\n\t\t\treturn '';\n\t\t}\n\t\toffset = idx;\n\t}\n\n\treturn haystack.substring(0, offset);\n}\n\nexport function convertSimple2RegExpPattern(pattern: string): string {\n\treturn pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\n\nexport function stripWildcards(pattern: string): string {\n\treturn pattern.replace(/\\*/g, '');\n}\n\n/**\n * Determines if haystack starts with needle.\n */\nexport function startsWith(haystack: string, needle: string): boolean {\n\tif (haystack.length < needle.length) {\n\t\treturn false;\n\t}\n\n\tif (haystack === needle) {\n\t\treturn true;\n\t}\n\n\tfor (let i = 0; i < needle.length; i++) {\n\t\tif (haystack[i] !== needle[i]) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\n/**\n * Determines if haystack ends with needle.\n */\nexport function endsWith(haystack: string, needle: string): boolean {\n\tlet diff = haystack.length - needle.length;\n\tif (diff > 0) {\n\t\treturn haystack.indexOf(needle, diff) === diff;\n\t} else if (diff === 0) {\n\t\treturn haystack === needle;\n\t} else {\n\t\treturn false;\n\t}\n}\n\nexport interface RegExpOptions {\n\tmatchCase?: boolean;\n\twholeWord?: boolean;\n\tmultiline?: boolean;\n\tglobal?: boolean;\n}\n\nexport function createRegExp(searchString: string, isRegex: boolean, options: RegExpOptions = {}): RegExp {\n\tif (!searchString) {\n\t\tthrow new Error('Cannot create regex from empty string');\n\t}\n\tif (!isRegex) {\n\t\tsearchString = escapeRegExpCharacters(searchString);\n\t}\n\tif (options.wholeWord) {\n\t\tif (!/\\B/.test(searchString.charAt(0))) {\n\t\t\tsearchString = '\\\\b' + searchString;\n\t\t}\n\t\tif (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n\t\t\tsearchString = searchString + '\\\\b';\n\t\t}\n\t}\n\tlet modifiers = '';\n\tif (options.global) {\n\t\tmodifiers += 'g';\n\t}\n\tif (!options.matchCase) {\n\t\tmodifiers += 'i';\n\t}\n\tif (options.multiline) {\n\t\tmodifiers += 'm';\n\t}\n\n\treturn new RegExp(searchString, modifiers);\n}\n\nexport function regExpLeadsToEndlessLoop(regexp: RegExp): boolean {\n\t// Exit early if it's one of these special cases which are meant to match\n\t// against an empty string\n\tif (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n\t\treturn false;\n\t}\n\n\t// We check against an empty string. If the regular expression doesn't advance\n\t// (e.g. ends in an endless loop) it will match an empty string.\n\tlet match = regexp.exec('');\n\treturn (match && <any>regexp.lastIndex === 0);\n}\n\nexport function regExpContainsBackreference(regexpValue: string): boolean {\n\treturn !!regexpValue.match(/([^\\\\]|^)(\\\\\\\\)*\\\\\\d+/);\n}\n\n/**\n * The normalize() method returns the Unicode Normalization Form of a given string. The form will be\n * the Normalization Form Canonical Composition.\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize}\n */\nexport const canNormalize = typeof ((<any>'').normalize) === 'function';\n\nconst nfcCache = new LRUCache<string, string>(10000); // bounded to 10000 elements\nexport function normalizeNFC(str: string): string {\n\treturn normalize(str, 'NFC', nfcCache);\n}\n\nconst nfdCache = new LRUCache<string, string>(10000); // bounded to 10000 elements\nexport function normalizeNFD(str: string): string {\n\treturn normalize(str, 'NFD', nfdCache);\n}\n\nconst nonAsciiCharactersPattern = /[^\\u0000-\\u0080]/;\nfunction normalize(str: string, form: string, normalizedCache: LRUCache<string, string>): string {\n\tif (!canNormalize || !str) {\n\t\treturn str;\n\t}\n\n\tconst cached = normalizedCache.get(str);\n\tif (cached) {\n\t\treturn cached;\n\t}\n\n\tlet res: string;\n\tif (nonAsciiCharactersPattern.test(str)) {\n\t\tres = (<any>str).normalize(form);\n\t} else {\n\t\tres = str;\n\t}\n\n\t// Use the cache for fast lookup\n\tnormalizedCache.set(str, res);\n\n\treturn res;\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: string): number {\n\tfor (let i = 0, len = str.length; i < len; i++) {\n\t\tlet chCode = str.charCodeAt(i);\n\t\tif (chCode !== CharCode.Space && chCode !== CharCode.Tab) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n}\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: string, start: number = 0, end: number = str.length): string {\n\tfor (let i = start; i < end; i++) {\n\t\tlet chCode = str.charCodeAt(i);\n\t\tif (chCode !== CharCode.Space && chCode !== CharCode.Tab) {\n\t\t\treturn str.substring(start, i);\n\t\t}\n\t}\n\treturn str.substring(start, end);\n}\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: string, startIndex: number = str.length - 1): number {\n\tfor (let i = startIndex; i >= 0; i--) {\n\t\tlet chCode = str.charCodeAt(i);\n\t\tif (chCode !== CharCode.Space && chCode !== CharCode.Tab) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n}\n\nexport function compare(a: string, b: string): number {\n\tif (a < b) {\n\t\treturn -1;\n\t} else if (a > b) {\n\t\treturn 1;\n\t} else {\n\t\treturn 0;\n\t}\n}\n\nexport function compareIgnoreCase(a: string, b: string): number {\n\tconst len = Math.min(a.length, b.length);\n\tfor (let i = 0; i < len; i++) {\n\t\tlet codeA = a.charCodeAt(i);\n\t\tlet codeB = b.charCodeAt(i);\n\n\t\tif (codeA === codeB) {\n\t\t\t// equal\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (isUpperAsciiLetter(codeA)) {\n\t\t\tcodeA += 32;\n\t\t}\n\n\t\tif (isUpperAsciiLetter(codeB)) {\n\t\t\tcodeB += 32;\n\t\t}\n\n\t\tconst diff = codeA - codeB;\n\n\t\tif (diff === 0) {\n\t\t\t// equal -> ignoreCase\n\t\t\tcontinue;\n\n\t\t} else if (isLowerAsciiLetter(codeA) && isLowerAsciiLetter(codeB)) {\n\t\t\t//\n\t\t\treturn diff;\n\n\t\t} else {\n\t\t\treturn compare(a.toLowerCase(), b.toLowerCase());\n\t\t}\n\t}\n\n\tif (a.length < b.length) {\n\t\treturn -1;\n\t} else if (a.length > b.length) {\n\t\treturn 1;\n\t} else {\n\t\treturn 0;\n\t}\n}\n\nfunction isLowerAsciiLetter(code: number): boolean {\n\treturn code >= CharCode.a && code <= CharCode.z;\n}\n\nfunction isUpperAsciiLetter(code: number): boolean {\n\treturn code >= CharCode.A && code <= CharCode.Z;\n}\n\nfunction isAsciiLetter(code: number): boolean {\n\treturn isLowerAsciiLetter(code) || isUpperAsciiLetter(code);\n}\n\nexport function equalsIgnoreCase(a: string, b: string): boolean {\n\tconst len1 = a ? a.length : 0;\n\tconst len2 = b ? b.length : 0;\n\n\tif (len1 !== len2) {\n\t\treturn false;\n\t}\n\n\treturn doEqualsIgnoreCase(a, b);\n}\n\nfunction doEqualsIgnoreCase(a: string, b: string, stopAt = a.length): boolean {\n\tif (typeof a !== 'string' || typeof b !== 'string') {\n\t\treturn false;\n\t}\n\n\tfor (let i = 0; i < stopAt; i++) {\n\t\tconst codeA = a.charCodeAt(i);\n\t\tconst codeB = b.charCodeAt(i);\n\n\t\tif (codeA === codeB) {\n\t\t\tcontinue;\n\t\t}\n\n\t\t// a-z A-Z\n\t\tif (isAsciiLetter(codeA) && isAsciiLetter(codeB)) {\n\t\t\tlet diff = Math.abs(codeA - codeB);\n\t\t\tif (diff !== 0 && diff !== 32) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\t// Any other charcode\n\t\telse {\n\t\t\tif (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn true;\n}\n\nexport function startsWithIgnoreCase(str: string, candidate: string): boolean {\n\tconst candidateLength = candidate.length;\n\tif (candidate.length > str.length) {\n\t\treturn false;\n\t}\n\n\treturn doEqualsIgnoreCase(str, candidate, candidateLength);\n}\n\n/**\n * @returns the length of the common prefix of the two strings.\n */\nexport function commonPrefixLength(a: string, b: string): number {\n\n\tlet i: number,\n\t\tlen = Math.min(a.length, b.length);\n\n\tfor (i = 0; i < len; i++) {\n\t\tif (a.charCodeAt(i) !== b.charCodeAt(i)) {\n\t\t\treturn i;\n\t\t}\n\t}\n\n\treturn len;\n}\n\n/**\n * @returns the length of the common suffix of the two strings.\n */\nexport function commonSuffixLength(a: string, b: string): number {\n\n\tlet i: number,\n\t\tlen = Math.min(a.length, b.length);\n\n\tlet aLastIndex = a.length - 1;\n\tlet bLastIndex = b.length - 1;\n\n\tfor (i = 0; i < len; i++) {\n\t\tif (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n\t\t\treturn i;\n\t\t}\n\t}\n\n\treturn len;\n}\n\nfunction substrEquals(a: string, aStart: number, aEnd: number, b: string, bStart: number, bEnd: number): boolean {\n\twhile (aStart < aEnd && bStart < bEnd) {\n\t\tif (a[aStart] !== b[bStart]) {\n\t\t\treturn false;\n\t\t}\n\t\taStart += 1;\n\t\tbStart += 1;\n\t}\n\treturn true;\n}\n\n/**\n * Return the overlap between the suffix of `a` and the prefix of `b`.\n * For instance `overlap(\"foobar\", \"arr, I'm a pirate\") === 2`.\n */\nexport function overlap(a: string, b: string): number {\n\tlet aEnd = a.length;\n\tlet bEnd = b.length;\n\tlet aStart = aEnd - bEnd;\n\n\tif (aStart === 0) {\n\t\treturn a === b ? aEnd : 0;\n\t} else if (aStart < 0) {\n\t\tbEnd += aStart;\n\t\taStart = 0;\n\t}\n\n\twhile (aStart < aEnd && bEnd > 0) {\n\t\tif (substrEquals(a, aStart, aEnd, b, 0, bEnd)) {\n\t\t\treturn bEnd;\n\t\t}\n\t\tbEnd -= 1;\n\t\taStart += 1;\n\t}\n\treturn 0;\n}\n\n// --- unicode\n// http://en.wikipedia.org/wiki/Surrogate_pair\n// Returns the code point starting at a specified index in a string\n// Code points U+0000 to U+D7FF and U+E000 to U+FFFF are represented on a single character\n// Code points U+10000 to U+10FFFF are represented on two consecutive characters\n//export function getUnicodePoint(str:string, index:number, len:number):number {\n//\tlet chrCode = str.charCodeAt(index);\n//\tif (0xD800 <= chrCode && chrCode <= 0xDBFF && index + 1 < len) {\n//\t\tlet nextChrCode = str.charCodeAt(index + 1);\n//\t\tif (0xDC00 <= nextChrCode && nextChrCode <= 0xDFFF) {\n//\t\t\treturn (chrCode - 0xD800) << 10 + (nextChrCode - 0xDC00) + 0x10000;\n//\t\t}\n//\t}\n//\treturn chrCode;\n//}\nexport function isHighSurrogate(charCode: number): boolean {\n\treturn (0xD800 <= charCode && charCode <= 0xDBFF);\n}\n\nexport function isLowSurrogate(charCode: number): boolean {\n\treturn (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n\n/**\n * Generated using https://github.com/alexandrudima/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/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nexport function containsRTL(str: string): boolean {\n\treturn CONTAINS_RTL.test(str);\n}\n\n/**\n * Generated using https://github.com/alexandrudima/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-\\uDEF8]|\\uD83E[\\uDD00-\\uDDE6])/;\n\nexport function containsEmoji(str: string): boolean {\n\treturn CONTAINS_EMOJI.test(str);\n}\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: string): boolean {\n\treturn IS_BASIC_ASCII.test(str);\n}\n\nexport function containsFullWidthCharacter(str: string): boolean {\n\tfor (let i = 0, len = str.length; i < len; i++) {\n\t\tif (isFullWidthCharacter(str.charCodeAt(i))) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nexport function isFullWidthCharacter(charCode: number): boolean {\n\t// Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n\t// http://jrgraphix.net/research/unicode_blocks.php\n\t// 2E80 — 2EFF CJK Radicals Supplement\n\t// 2F00 — 2FDF Kangxi Radicals\n\t// 2FF0 — 2FFF Ideographic Description Characters\n\t// 3000 — 303F CJK Symbols and Punctuation\n\t// 3040 — 309F Hiragana\n\t// 30A0 — 30FF Katakana\n\t// 3100 — 312F Bopomofo\n\t// 3130 — 318F Hangul Compatibility Jamo\n\t// 3190 — 319F Kanbun\n\t// 31A0 — 31BF Bopomofo Extended\n\t// 31F0 — 31FF Katakana Phonetic Extensions\n\t// 3200 — 32FF Enclosed CJK Letters and Months\n\t// 3300 — 33FF CJK Compatibility\n\t// 3400 — 4DBF CJK Unified Ideographs Extension A\n\t// 4DC0 — 4DFF Yijing Hexagram Symbols\n\t// 4E00 — 9FFF CJK Unified Ideographs\n\t// A000 — A48F Yi Syllables\n\t// A490 — A4CF Yi Radicals\n\t// AC00 — D7AF Hangul Syllables\n\t// [IGNORE] D800 — DB7F High Surrogates\n\t// [IGNORE] DB80 — DBFF High Private Use Surrogates\n\t// [IGNORE] DC00 — DFFF Low Surrogates\n\t// [IGNORE] E000 — F8FF Private Use Area\n\t// F900 — FAFF CJK Compatibility Ideographs\n\t// [IGNORE] FB00 — FB4F Alphabetic Presentation Forms\n\t// [IGNORE] FB50 — FDFF Arabic Presentation Forms-A\n\t// [IGNORE] FE00 — FE0F Variation Selectors\n\t// [IGNORE] FE20 — FE2F Combining Half Marks\n\t// [IGNORE] FE30 — FE4F CJK Compatibility Forms\n\t// [IGNORE] FE50 — FE6F Small Form Variants\n\t// [IGNORE] FE70 — FEFF Arabic Presentation Forms-B\n\t// FF00 — FFEF Halfwidth and Fullwidth Forms\n\t// [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n\t// of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n\t// [IGNORE] and FF65 - FFDC halfwidth of Katakana and Hangul\n\t// [IGNORE] FFF0 — FFFF Specials\n\tcharCode = +charCode; // @perf\n\treturn (\n\t\t(charCode >= 0x2E80 && charCode <= 0xD7AF)\n\t\t|| (charCode >= 0xF900 && charCode <= 0xFAFF)\n\t\t|| (charCode >= 0xFF01 && charCode <= 0xFF5E)\n\t);\n}\n\n/**\n * Given a string and a max length returns a shorted version. Shorting\n * happens at favorable positions - such as whitespace or punctuation characters.\n */\nexport function lcut(text: string, n: number) {\n\tif (text.length < n) {\n\t\treturn text;\n\t}\n\n\tconst re = /\\b/g;\n\tlet i = 0;\n\twhile (re.test(text)) {\n\t\tif (text.length - re.lastIndex < n) {\n\t\t\tbreak;\n\t\t}\n\n\t\ti = re.lastIndex;\n\t\tre.lastIndex += 1;\n\t}\n\n\treturn text.substring(i).replace(/^\\s/, empty);\n}\n\n// Escape codes\n// http://en.wikipedia.org/wiki/ANSI_escape_code\nconst EL = /\\x1B\\x5B[12]?K/g; // Erase in line\nconst COLOR_START = /\\x1b\\[\\d+m/g; // Color\nconst COLOR_END = /\\x1b\\[0?m/g; // Color\n\nexport function removeAnsiEscapeCodes(str: string): string {\n\tif (str) {\n\t\tstr = str.replace(EL, '');\n\t\tstr = str.replace(COLOR_START, '');\n\t\tstr = str.replace(COLOR_END, '');\n\t}\n\n\treturn str;\n}\n\n// -- UTF-8 BOM\n\nexport const UTF8_BOM_CHARACTER = String.fromCharCode(CharCode.UTF8_BOM);\n\nexport function startsWithUTF8BOM(str: string): boolean {\n\treturn (str && str.length > 0 && str.charCodeAt(0) === CharCode.UTF8_BOM);\n}\n\nexport function stripUTF8BOM(str: string): string {\n\treturn startsWithUTF8BOM(str) ? str.substr(1) : str;\n}\n\nexport function safeBtoa(str: string): string {\n\treturn btoa(encodeURIComponent(str)); // we use encodeURIComponent because btoa fails for non Latin 1 values\n}\n\nexport function repeat(s: string, count: number): string {\n\tlet result = '';\n\tfor (let i = 0; i < count; i++) {\n\t\tresult += s;\n\t}\n\treturn result;\n}\n\n/**\n * Checks if the characters of the provided query string are included in the\n * target string. The characters do not have to be contiguous within the string.\n */\nexport function fuzzyContains(target: string, query: string): boolean {\n\tif (!target || !query) {\n\t\treturn false; // return early if target or query are undefined\n\t}\n\n\tif (target.length < query.length) {\n\t\treturn false; // impossible for query to be contained in target\n\t}\n\n\tconst queryLen = query.length;\n\tconst targetLower = target.toLowerCase();\n\n\tlet index = 0;\n\tlet lastIndexOf = -1;\n\twhile (index < queryLen) {\n\t\tlet indexOf = targetLower.indexOf(query[index], lastIndexOf + 1);\n\t\tif (indexOf < 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tlastIndexOf = indexOf;\n\n\t\tindex++;\n\t}\n\n\treturn true;\n}\n\nexport function containsUppercaseCharacter(target: string, ignoreEscapedChars = false): boolean {\n\tif (!target) {\n\t\treturn false;\n\t}\n\n\tif (ignoreEscapedChars) {\n\t\ttarget = target.replace(/\\\\./g, '');\n\t}\n\n\treturn target.toLowerCase() !== target;\n}\n","/**\n * Extracted from https://github.com/winjs/winjs\n * Version: 4.4.0(ec3258a9f3a36805a187848984e3bb938044178d)\n * Copyright (c) Microsoft Corporation.\n * All Rights Reserved.\n * Licensed under the MIT License.\n */\nvar __winjs_exports;\n\n(function() {\n\nvar _modules = Object.create(null);//{};\n_modules[\"WinJS/Core/_WinJS\"] = {};\n\nvar _winjs = function(moduleId, deps, factory) {\n var exports = {};\n var exportsPassedIn = false;\n\n var depsValues = deps.map(function(dep) {\n if (dep === 'exports') {\n exportsPassedIn = true;\n return exports;\n }\n return _modules[dep];\n });\n\n var result = factory.apply({}, depsValues);\n\n _modules[moduleId] = exportsPassedIn ? exports : result;\n};\n\n\n_winjs(\"WinJS/Core/_Global\", [], function () {\n \"use strict\";\n\n // Appease jshint\n /* global window, self, global */\n\n var globalObject =\n typeof window !== 'undefined' ? window :\n typeof self !== 'undefined' ? self :\n typeof global !== 'undefined' ? global :\n {};\n return globalObject;\n});\n\n_winjs(\"WinJS/Core/_BaseCoreUtils\", [\"WinJS/Core/_Global\"], function baseCoreUtilsInit(_Global) {\n \"use strict\";\n\n var hasWinRT = !!_Global.Windows;\n\n function markSupportedForProcessing(func) {\n /// <signature helpKeyword=\"WinJS.Utilities.markSupportedForProcessing\">\n /// <summary locid=\"WinJS.Utilities.markSupportedForProcessing\">\n /// Marks a function as being compatible with declarative processing, such as WinJS.UI.processAll\n /// or WinJS.Binding.processAll.\n /// </summary>\n /// <param name=\"func\" type=\"Function\" locid=\"WinJS.Utilities.markSupportedForProcessing_p:func\">\n /// The function to be marked as compatible with declarative processing.\n /// </param>\n /// <returns type=\"Function\" locid=\"WinJS.Utilities.markSupportedForProcessing_returnValue\">\n /// The input function.\n /// </returns>\n /// </signature>\n func.supportedForProcessing = true;\n return func;\n }\n\n var actualSetImmediate = null;\n\n return {\n hasWinRT: hasWinRT,\n markSupportedForProcessing: markSupportedForProcessing,\n _setImmediate: function (callback) {\n // BEGIN monaco change\n if (actualSetImmediate === null) {\n if (_Global.setImmediate) {\n actualSetImmediate = _Global.setImmediate.bind(_Global);\n } else if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {\n actualSetImmediate = process.nextTick.bind(process);\n } else {\n actualSetImmediate = _Global.setTimeout.bind(_Global);\n }\n }\n actualSetImmediate(callback);\n // END monaco change\n }\n };\n});\n_winjs(\"WinJS/Core/_WriteProfilerMark\", [\"WinJS/Core/_Global\"], function profilerInit(_Global) {\n \"use strict\";\n\n return _Global.msWriteProfilerMark || function () { };\n});\n_winjs(\"WinJS/Core/_Base\", [\"WinJS/Core/_WinJS\",\"WinJS/Core/_Global\",\"WinJS/Core/_BaseCoreUtils\",\"WinJS/Core/_WriteProfilerMark\"], function baseInit(_WinJS, _Global, _BaseCoreUtils, _WriteProfilerMark) {\n \"use strict\";\n\n function initializeProperties(target, members, prefix) {\n var keys = Object.keys(members);\n var isArray = Array.isArray(target);\n var properties;\n var i, len;\n for (i = 0, len = keys.length; i < len; i++) {\n var key = keys[i];\n var enumerable = key.charCodeAt(0) !== /*_*/95;\n var member = members[key];\n if (member && typeof member === 'object') {\n if (member.value !== undefined || typeof member.get === 'function' || typeof member.set === 'function') {\n if (member.enumerable === undefined) {\n member.enumerable = enumerable;\n }\n if (prefix && member.setName && typeof member.setName === 'function') {\n member.setName(prefix + \".\" + key);\n }\n properties = properties || {};\n properties[key] = member;\n continue;\n }\n }\n if (!enumerable) {\n properties = properties || {};\n properties[key] = { value: member, enumerable: enumerable, configurable: true, writable: true };\n continue;\n }\n if (isArray) {\n target.forEach(function (target) {\n target[key] = member;\n });\n } else {\n target[key] = member;\n }\n }\n if (properties) {\n if (isArray) {\n target.forEach(function (target) {\n Object.defineProperties(target, properties);\n });\n } else {\n Object.defineProperties(target, properties);\n }\n }\n }\n\n (function () {\n\n var _rootNamespace = _WinJS;\n if (!_rootNamespace.Namespace) {\n _rootNamespace.Namespace = Object.create(Object.prototype);\n }\n\n function createNamespace(parentNamespace, name) {\n var currentNamespace = parentNamespace || {};\n if (name) {\n var namespaceFragments = name.split(\".\");\n if (currentNamespace === _Global && namespaceFragments[0] === \"WinJS\") {\n currentNamespace = _WinJS;\n namespaceFragments.splice(0, 1);\n }\n for (var i = 0, len = namespaceFragments.length; i < len; i++) {\n var namespaceName = namespaceFragments[i];\n if (!currentNamespace[namespaceName]) {\n Object.defineProperty(currentNamespace, namespaceName,\n { value: {}, writable: false, enumerable: true, configurable: true }\n );\n }\n currentNamespace = currentNamespace[namespaceName];\n }\n }\n return currentNamespace;\n }\n\n function defineWithParent(parentNamespace, name, members) {\n /// <signature helpKeyword=\"WinJS.Namespace.defineWithParent\">\n /// <summary locid=\"WinJS.Namespace.defineWithParent\">\n /// Defines a new namespace with the specified name under the specified parent namespace.\n /// </summary>\n /// <param name=\"parentNamespace\" type=\"Object\" locid=\"WinJS.Namespace.defineWithParent_p:parentNamespace\">\n /// The parent namespace.\n /// </param>\n /// <param name=\"name\" type=\"String\" locid=\"WinJS.Namespace.defineWithParent_p:name\">\n /// The name of the new namespace.\n /// </param>\n /// <param name=\"members\" type=\"Object\" locid=\"WinJS.Namespace.defineWithParent_p:members\">\n /// The members of the new namespace.\n /// </param>\n /// <returns type=\"Object\" locid=\"WinJS.Namespace.defineWithParent_returnValue\">\n /// The newly-defined namespace.\n /// </returns>\n /// </signature>\n var currentNamespace = createNamespace(parentNamespace, name);\n\n if (members) {\n initializeProperties(currentNamespace, members, name || \"<ANONYMOUS>\");\n }\n\n return currentNamespace;\n }\n\n function define(name, members) {\n /// <signature helpKeyword=\"WinJS.Namespace.define\">\n /// <summary locid=\"WinJS.Namespace.define\">\n /// Defines a new namespace with the specified name.\n /// </summary>\n /// <param name=\"name\" type=\"String\" locid=\"WinJS.Namespace.define_p:name\">\n /// The name of the namespace. This could be a dot-separated name for nested namespaces.\n /// </param>\n /// <param name=\"members\" type=\"Object\" locid=\"WinJS.Namespace.define_p:members\">\n /// The members of the new namespace.\n /// </param>\n /// <returns type=\"Object\" locid=\"WinJS.Namespace.define_returnValue\">\n /// The newly-defined namespace.\n /// </returns>\n /// </signature>\n return defineWithParent(_Global, name, members);\n }\n\n var LazyStates = {\n uninitialized: 1,\n working: 2,\n initialized: 3,\n };\n\n function lazy(f) {\n var name;\n var state = LazyStates.uninitialized;\n var result;\n return {\n setName: function (value) {\n name = value;\n },\n get: function () {\n switch (state) {\n case LazyStates.initialized:\n return result;\n\n case LazyStates.uninitialized:\n state = LazyStates.working;\n try {\n _WriteProfilerMark(\"WinJS.Namespace._lazy:\" + name + \",StartTM\");\n result = f();\n } finally {\n _WriteProfilerMark(\"WinJS.Namespace._lazy:\" + name + \",StopTM\");\n state = LazyStates.uninitialized;\n }\n f = null;\n state = LazyStates.initialized;\n return result;\n\n case LazyStates.working:\n throw \"Illegal: reentrancy on initialization\";\n\n default:\n throw \"Illegal\";\n }\n },\n set: function (value) {\n switch (state) {\n case LazyStates.working:\n throw \"Illegal: reentrancy on initialization\";\n\n default:\n state = LazyStates.initialized;\n result = value;\n break;\n }\n },\n enumerable: true,\n configurable: true,\n };\n }\n\n // helper for defining AMD module members\n function moduleDefine(exports, name, members) {\n var target = [exports];\n var publicNS = null;\n if (name) {\n publicNS = createNamespace(_Global, name);\n target.push(publicNS);\n }\n initializeProperties(target, members, name || \"<ANONYMOUS>\");\n return publicNS;\n }\n\n // Establish members of the \"WinJS.Namespace\" namespace\n Object.defineProperties(_rootNamespace.Namespace, {\n\n defineWithParent: { value: defineWithParent, writable: true, enumerable: true, configurable: true },\n\n define: { value: define, writable: true, enumerable: true, configurable: true },\n\n _lazy: { value: lazy, writable: true, enumerable: true, configurable: true },\n\n _moduleDefine: { value: moduleDefine, writable: true, enumerable: true, configurable: true }\n\n });\n\n })();\n\n (function () {\n\n function define(constructor, instanceMembers, staticMembers) {\n /// <signature helpKeyword=\"WinJS.Class.define\">\n /// <summary locid=\"WinJS.Class.define\">\n /// Defines a class using the given constructor and the specified instance members.\n /// </summary>\n /// <param name=\"constructor\" type=\"Function\" locid=\"WinJS.Class.define_p:constructor\">\n /// A constructor function that is used to instantiate this class.\n /// </param>\n /// <param name=\"instanceMembers\" type=\"Object\" locid=\"WinJS.Class.define_p:instanceMembers\">\n /// The set of instance fields, properties, and methods made available on the class.\n /// </param>\n /// <param name=\"staticMembers\" type=\"Object\" locid=\"WinJS.Class.define_p:staticMembers\">\n /// The set of static fields, properties, and methods made available on the class.\n /// </param>\n /// <returns type=\"Function\" locid=\"WinJS.Class.define_returnValue\">\n /// The newly-defined class.\n /// </returns>\n /// </signature>\n constructor = constructor || function () { };\n _BaseCoreUtils.markSupportedForProcessing(constructor);\n if (instanceMembers) {\n initializeProperties(constructor.prototype, instanceMembers);\n }\n if (staticMembers) {\n initializeProperties(constructor, staticMembers);\n }\n return constructor;\n }\n\n function derive(baseClass, constructor, instanceMembers, staticMembers) {\n /// <signature helpKeyword=\"WinJS.Class.derive\">\n /// <summary locid=\"WinJS.Class.derive\">\n /// Creates a sub-class based on the supplied baseClass parameter, using prototypal inheritance.\n /// </summary>\n /// <param name=\"baseClass\" type=\"Function\" locid=\"WinJS.Class.derive_p:baseClass\">\n /// The class to inherit from.\n /// </param>\n /// <param name=\"constructor\" type=\"Function\" locid=\"WinJS.Class.derive_p:constructor\">\n /// A constructor function that is used to instantiate this class.\n /// </param>\n /// <param name=\"instanceMembers\" type=\"Object\" locid=\"WinJS.Class.derive_p:instanceMembers\">\n /// The set of instance fields, properties, and methods to be made available on the class.\n /// </param>\n /// <param name=\"staticMembers\" type=\"Object\" locid=\"WinJS.Class.derive_p:staticMembers\">\n /// The set of static fields, properties, and methods to be made available on the class.\n /// </param>\n /// <returns type=\"Function\" locid=\"WinJS.Class.derive_returnValue\">\n /// The newly-defined class.\n /// </returns>\n /// </signature>\n if (baseClass) {\n constructor = constructor || function () { };\n var basePrototype = baseClass.prototype;\n constructor.prototype = Object.create(basePrototype);\n _BaseCoreUtils.markSupportedForProcessing(constructor);\n Object.defineProperty(constructor.prototype, \"constructor\", { value: constructor, writable: true, configurable: true, enumerable: true });\n if (instanceMembers) {\n initializeProperties(constructor.prototype, instanceMembers);\n }\n if (staticMembers) {\n initializeProperties(constructor, staticMembers);\n }\n return constructor;\n } else {\n return define(constructor, instanceMembers, staticMembers);\n }\n }\n\n function mix(constructor) {\n /// <signature helpKeyword=\"WinJS.Class.mix\">\n /// <summary locid=\"WinJS.Class.mix\">\n /// Defines a class using the given constructor and the union of the set of instance members\n /// specified by all the mixin objects. The mixin parameter list is of variable length.\n /// </summary>\n /// <param name=\"constructor\" locid=\"WinJS.Class.mix_p:constructor\">\n /// A constructor function that is used to instantiate this class.\n /// </param>\n /// <returns type=\"Function\" locid=\"WinJS.Class.mix_returnValue\">\n /// The newly-defined class.\n /// </returns>\n /// </signature>\n constructor = constructor || function () { };\n var i, len;\n for (i = 1, len = arguments.length; i < len; i++) {\n initializeProperties(constructor.prototype, arguments[i]);\n }\n return constructor;\n }\n\n // Establish members of \"WinJS.Class\" namespace\n _WinJS.Namespace.define(\"WinJS.Class\", {\n define: define,\n derive: derive,\n mix: mix\n });\n\n })();\n\n return {\n Namespace: _WinJS.Namespace,\n Class: _WinJS.Class\n };\n\n});\n_winjs(\"WinJS/Core/_ErrorFromName\", [\"WinJS/Core/_Base\"], function errorsInit(_Base) {\n \"use strict\";\n\n var ErrorFromName = _Base.Class.derive(Error, function (name, message) {\n /// <signature helpKeyword=\"WinJS.ErrorFromName\">\n /// <summary locid=\"WinJS.ErrorFromName\">\n /// Creates an Error object with the specified name and message properties.\n /// </summary>\n /// <param name=\"name\" type=\"String\" locid=\"WinJS.ErrorFromName_p:name\">The name of this error. The name is meant to be consumed programmatically and should not be localized.</param>\n /// <param name=\"message\" type=\"String\" optional=\"true\" locid=\"WinJS.ErrorFromName_p:message\">The message for this error. The message is meant to be consumed by humans and should be localized.</param>\n /// <returns type=\"Error\" locid=\"WinJS.ErrorFromName_returnValue\">Error instance with .name and .message properties populated</returns>\n /// </signature>\n this.name = name;\n this.message = message || name;\n }, {\n /* empty */\n }, {\n supportedForProcessing: false,\n });\n\n _Base.Namespace.define(\"WinJS\", {\n // ErrorFromName establishes a simple pattern for returning error codes.\n //\n ErrorFromName: ErrorFromName\n });\n\n return ErrorFromName;\n\n});\n\n\n_winjs(\"WinJS/Core/_Events\", [\"exports\",\"WinJS/Core/_Base\"], function eventsInit(exports, _Base) {\n \"use strict\";\n\n\n function createEventProperty(name) {\n var eventPropStateName = \"_on\" + name + \"state\";\n\n return {\n get: function () {\n var state = this[eventPropStateName];\n return state && state.userHandler;\n },\n set: function (handler) {\n var state = this[eventPropStateName];\n if (handler) {\n if (!state) {\n state = { wrapper: function (evt) { return state.userHandler(evt); }, userHandler: handler };\n Object.defineProperty(this, eventPropStateName, { value: state, enumerable: false, writable:true, configurable: true });\n this.addEventListener(name, state.wrapper, false);\n }\n state.userHandler = handler;\n } else if (state) {\n this.removeEventListener(name, state.wrapper, false);\n this[eventPropStateName] = null;\n }\n },\n enumerable: true\n };\n }\n\n function createEventProperties() {\n /// <signature helpKeyword=\"WinJS.Utilities.createEventProperties\">\n /// <summary locid=\"WinJS.Utilities.createEventProperties\">\n /// Creates an object that has one property for each name passed to the function.\n /// </summary>\n /// <param name=\"events\" locid=\"WinJS.Utilities.createEventProperties_p:events\">\n /// A variable list of property names.\n /// </param>\n /// <returns type=\"Object\" locid=\"WinJS.Utilities.createEventProperties_returnValue\">\n /// The object with the specified properties. The names of the properties are prefixed with 'on'.\n /// </returns>\n /// </signature>\n var props = {};\n for (var i = 0, len = arguments.length; i < len; i++) {\n var name = arguments[i];\n props[\"on\" + name] = createEventProperty(name);\n }\n return props;\n }\n\n var EventMixinEvent = _Base.Class.define(\n function EventMixinEvent_ctor(type, detail, target) {\n this.detail = detail;\n this.target = target;\n this.timeStamp = Date.now();\n this.type = type;\n },\n {\n bubbles: { value: false, writable: false },\n cancelable: { value: false, writable: false },\n currentTarget: {\n get: function () { return this.target; }\n },\n defaultPrevented: {\n get: function () { return this._preventDefaultCalled; }\n },\n trusted: { value: false, writable: false },\n eventPhase: { value: 0, writable: false },\n target: null,\n timeStamp: null,\n type: null,\n\n preventDefault: function () {\n this._preventDefaultCalled = true;\n },\n stopImmediatePropagation: function () {\n this._stopImmediatePropagationCalled = true;\n },\n stopPropagation: function () {\n }\n }, {\n supportedForProcessing: false,\n }\n );\n\n var eventMixin = {\n _listeners: null,\n\n addEventListener: function (type, listener, useCapture) {\n /// <signature helpKeyword=\"WinJS.Utilities.eventMixin.addEventListener\">\n /// <summary locid=\"WinJS.Utilities.eventMixin.addEventListener\">\n /// Adds an event listener to the control.\n /// </summary>\n /// <param name=\"type\" locid=\"WinJS.Utilities.eventMixin.addEventListener_p:type\">\n /// The type (name) of the event.\n /// </param>\n /// <param name=\"listener\" locid=\"WinJS.Utilities.eventMixin.addEventListener_p:listener\">\n /// The listener to invoke when the event is raised.\n /// </param>\n /// <param name=\"useCapture\" locid=\"WinJS.Utilities.eventMixin.addEventListener_p:useCapture\">\n /// if true initiates capture, otherwise false.\n /// </param>\n /// </signature>\n useCapture = useCapture || false;\n this._listeners = this._listeners || {};\n var eventListeners = (this._listeners[type] = this._listeners[type] || []);\n for (var i = 0, len = eventListeners.length; i < len; i++) {\n var l = eventListeners[i];\n if (l.useCapture === useCapture && l.listener === listener) {\n return;\n }\n }\n eventListeners.push({ listener: listener, useCapture: useCapture });\n },\n dispatchEvent: function (type, details) {\n /// <signature helpKeyword=\"WinJS.Utilities.eventMixin.dispatchEvent\">\n /// <summary locid=\"WinJS.Utilities.eventMixin.dispatchEvent\">\n /// Raises an event of the specified type and with the specified additional properties.\n /// </summary>\n /// <param name=\"type\" locid=\"WinJS.Utilities.eventMixin.dispatchEvent_p:type\">\n /// The type (name) of the event.\n /// </param>\n /// <param name=\"details\" locid=\"WinJS.Utilities.eventMixin.dispatchEvent_p:details\">\n /// The set of additional properties to be attached to the event object when the event is raised.\n /// </param>\n /// <returns type=\"Boolean\" locid=\"WinJS.Utilities.eventMixin.dispatchEvent_returnValue\">\n /// true if preventDefault was called on the event.\n /// </returns>\n /// </signature>\n var listeners = this._listeners && this._listeners[type];\n if (listeners) {\n var eventValue = new EventMixinEvent(type, details, this);\n // Need to copy the array to protect against people unregistering while we are dispatching\n listeners = listeners.slice(0, listeners.length);\n for (var i = 0, len = listeners.length; i < len && !eventValue._stopImmediatePropagationCalled; i++) {\n listeners[i].listener(eventValue);\n }\n return eventValue.defaultPrevented || false;\n }\n return false;\n },\n removeEventListener: function (type, listener, useCapture) {\n /// <signature helpKeyword=\"WinJS.Utilities.eventMixin.removeEventListener\">\n /// <summary locid=\"WinJS.Utilities.eventMixin.removeEventListener\">\n /// Removes an event listener from the control.\n /// </summary>\n /// <param name=\"type\" locid=\"WinJS.Utilities.eventMixin.removeEventListener_p:type\">\n /// The type (name) of the event.\n /// </param>\n /// <param name=\"listener\" locid=\"WinJS.Utilities.eventMixin.removeEventListener_p:listener\">\n /// The listener to remove.\n /// </param>\n /// <param name=\"useCapture\" locid=\"WinJS.Utilities.eventMixin.removeEventListener_p:useCapture\">\n /// Specifies whether to initiate capture.\n /// </param>\n /// </signature>\n useCapture = useCapture || false;\n var listeners = this._listeners && this._listeners[type];\n if (listeners) {\n for (var i = 0, len = listeners.length; i < len; i++) {\n var l = listeners[i];\n if (l.listener === listener && l.useCapture === useCapture) {\n listeners.splice(i, 1);\n if (listeners.length === 0) {\n delete this._listeners[type];\n }\n // Only want to remove one element for each call to removeEventListener\n break;\n }\n }\n }\n }\n };\n\n _Base.Namespace._moduleDefine(exports, \"WinJS.Utilities\", {\n _createEventProperty: createEventProperty,\n createEventProperties: createEventProperties,\n eventMixin: eventMixin\n });\n\n});\n\n\n_winjs(\"WinJS/Core/_Trace\", [\"WinJS/Core/_Global\"], function traceInit(_Global) {\n \"use strict\";\n\n function nop(v) {\n return v;\n }\n\n return {\n _traceAsyncOperationStarting: (_Global.Debug && _Global.Debug.msTraceAsyncOperationStarting && _Global.Debug.msTraceAsyncOperationStarting.bind(_Global.Debug)) || nop,\n _traceAsyncOperationCompleted: (_Global.Debug && _Global.Debug.msTraceAsyncOperationCompleted && _Global.Debug.msTraceAsyncOperationCompleted.bind(_Global.Debug)) || nop,\n _traceAsyncCallbackStarting: (_Global.Debug && _Global.Debug.msTraceAsyncCallbackStarting && _Global.Debug.msTraceAsyncCallbackStarting.bind(_Global.Debug)) || nop,\n _traceAsyncCallbackCompleted: (_Global.Debug && _Global.Debug.msTraceAsyncCallbackCompleted && _Global.Debug.msTraceAsyncCallbackCompleted.bind(_Global.Debug)) || nop\n };\n});\n_winjs(\"WinJS/Promise/_StateMachine\", [\"WinJS/Core/_Global\",\"WinJS/Core/_BaseCoreUtils\",\"WinJS/Core/_Base\",\"WinJS/Core/_ErrorFromName\",\"WinJS/Core/_Events\",\"WinJS/Core/_Trace\"], function promiseStateMachineInit(_Global, _BaseCoreUtils, _Base, _ErrorFromName, _Events, _Trace) {\n \"use strict\";\n\n _Global.Debug && (_Global.Debug.setNonUserCodeExceptions = true);\n\n var ListenerType = _Base.Class.mix(_Base.Class.define(null, { /*empty*/ }, { supportedForProcessing: false }), _Events.eventMixin);\n var promiseEventListeners = new ListenerType();\n // make sure there is a listeners collection so that we can do a more trivial check below\n promiseEventListeners._listeners = {};\n var errorET = \"error\";\n var canceledName = \"Canceled\";\n var tagWithStack = false;\n var tag = {\n promise: 0x01,\n thenPromise: 0x02,\n errorPromise: 0x04,\n exceptionPromise: 0x08,\n completePromise: 0x10,\n };\n tag.all = tag.promise | tag.thenPromise | tag.errorPromise | tag.exceptionPromise | tag.completePromise;\n\n //\n // Global error counter, for each error which enters the system we increment this once and then\n // the error number travels with the error as it traverses the tree of potential handlers.\n //\n // When someone has registered to be told about errors (WinJS.Promise.callonerror) promises\n // which are in error will get tagged with a ._errorId field. This tagged field is the\n // contract by which nested promises with errors will be identified as chaining for the\n // purposes of the callonerror semantics. If a nested promise in error is encountered without\n // a ._errorId it will be assumed to be foreign and treated as an interop boundary and\n // a new error id will be minted.\n //\n var error_number = 1;\n\n //\n // The state machine has a interesting hiccup in it with regards to notification, in order\n // to flatten out notification and avoid recursion for synchronous completion we have an\n // explicit set of *_notify states which are responsible for notifying their entire tree\n // of children. They can do this because they know that immediate children are always\n // ThenPromise instances and we can therefore reach into their state to access the\n // _listeners collection.\n //\n // So, what happens is that a Promise will be fulfilled through the _completed or _error\n // messages at which point it will enter a *_notify state and be responsible for to move\n // its children into an (as appropriate) success or error state and also notify that child's\n // listeners of the state transition, until leaf notes are reached.\n //\n\n var state_created, // -> working\n state_working, // -> error | error_notify | success | success_notify | canceled | waiting\n state_waiting, // -> error | error_notify | success | success_notify | waiting_canceled\n state_waiting_canceled, // -> error | error_notify | success | success_notify | canceling\n state_canceled, // -> error | error_notify | success | success_notify | canceling\n state_canceling, // -> error_notify\n state_success_notify, // -> success\n state_success, // -> .\n state_error_notify, // -> error\n state_error; // -> .\n\n // Noop function, used in the various states to indicate that they don't support a given\n // message. Named with the somewhat cute name '_' because it reads really well in the states.\n\n function _() { }\n\n // Initial state\n //\n state_created = {\n name: \"created\",\n enter: function (promise) {\n promise._setState(state_working);\n },\n cancel: _,\n done: _,\n then: _,\n _completed: _,\n _error: _,\n _notify: _,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n // Ready state, waiting for a message (completed/error/progress), able to be canceled\n //\n state_working = {\n name: \"working\",\n enter: _,\n cancel: function (promise) {\n promise._setState(state_canceled);\n },\n done: done,\n then: then,\n _completed: completed,\n _error: error,\n _notify: _,\n _progress: progress,\n _setCompleteValue: setCompleteValue,\n _setErrorValue: setErrorValue\n };\n\n // Waiting state, if a promise is completed with a value which is itself a promise\n // (has a then() method) it signs up to be informed when that child promise is\n // fulfilled at which point it will be fulfilled with that value.\n //\n state_waiting = {\n name: \"waiting\",\n enter: function (promise) {\n var waitedUpon = promise._value;\n // We can special case our own intermediate promises which are not in a\n // terminal state by just pushing this promise as a listener without\n // having to create new indirection functions\n if (waitedUpon instanceof ThenPromise &&\n waitedUpon._state !== state_error &&\n waitedUpon._state !== state_success) {\n pushListener(waitedUpon, { promise: promise });\n } else {\n var error = function (value) {\n if (waitedUpon._errorId) {\n promise._chainedError(value, waitedUpon);\n } else {\n // Because this is an interop boundary we want to indicate that this\n // error has been handled by the promise infrastructure before we\n // begin a new handling chain.\n //\n callonerror(promise, value, detailsForHandledError, waitedUpon, error);\n promise._error(value);\n }\n };\n error.handlesOnError = true;\n waitedUpon.then(\n promise._completed.bind(promise),\n error,\n promise._progress.bind(promise)\n );\n }\n },\n cancel: function (promise) {\n promise._setState(state_waiting_canceled);\n },\n done: done,\n then: then,\n _completed: completed,\n _error: error,\n _notify: _,\n _progress: progress,\n _setCompleteValue: setCompleteValue,\n _setErrorValue: setErrorValue\n };\n\n // Waiting canceled state, when a promise has been in a waiting state and receives a\n // request to cancel its pending work it will forward that request to the child promise\n // and then waits to be informed of the result. This promise moves itself into the\n // canceling state but understands that the child promise may instead push it to a\n // different state.\n //\n state_waiting_canceled = {\n name: \"waiting_canceled\",\n enter: function (promise) {\n // Initiate a transition to canceling. Triggering a cancel on the promise\n // that we are waiting upon may result in a different state transition\n // before the state machine pump runs again.\n promise._setState(state_canceling);\n var waitedUpon = promise._value;\n if (waitedUpon.cancel) {\n waitedUpon.cancel();\n }\n },\n cancel: _,\n done: done,\n then: then,\n _completed: completed,\n _error: error,\n _notify: _,\n _progress: progress,\n _setCompleteValue: setCompleteValue,\n _setErrorValue: setErrorValue\n };\n\n // Canceled state, moves to the canceling state and then tells the promise to do\n // whatever it might need to do on cancelation.\n //\n state_canceled = {\n name: \"canceled\",\n enter: function (promise) {\n // Initiate a transition to canceling. The _cancelAction may change the state\n // before the state machine pump runs again.\n promise._setState(state_canceling);\n promise._cancelAction();\n },\n cancel: _,\n done: done,\n then: then,\n _completed: completed,\n _error: error,\n _notify: _,\n _progress: progress,\n _setCompleteValue: setCompleteValue,\n _setErrorValue: setErrorValue\n };\n\n // Canceling state, commits to the promise moving to an error state with an error\n // object whose 'name' and 'message' properties contain the string \"Canceled\"\n //\n state_canceling = {\n name: \"canceling\",\n enter: function (promise) {\n var error = new Error(canceledName);\n error.name = error.message;\n promise._value = error;\n promise._setState(state_error_notify);\n },\n cancel: _,\n done: _,\n then: _,\n _completed: _,\n _error: _,\n _notify: _,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n // Success notify state, moves a promise to the success state and notifies all children\n //\n state_success_notify = {\n name: \"complete_notify\",\n enter: function (promise) {\n promise.done = CompletePromise.prototype.done;\n promise.then = CompletePromise.prototype.then;\n if (promise._listeners) {\n var queue = [promise];\n var p;\n while (queue.length) {\n p = queue.shift();\n p._state._notify(p, queue);\n }\n }\n promise._setState(state_success);\n },\n cancel: _,\n done: null, /*error to get here */\n then: null, /*error to get here */\n _completed: _,\n _error: _,\n _notify: notifySuccess,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n // Success state, moves a promise to the success state and does NOT notify any children.\n // Some upstream promise is owning the notification pass.\n //\n state_success = {\n name: \"success\",\n enter: function (promise) {\n promise.done = CompletePromise.prototype.done;\n promise.then = CompletePromise.prototype.then;\n promise._cleanupAction();\n },\n cancel: _,\n done: null, /*error to get here */\n then: null, /*error to get here */\n _completed: _,\n _error: _,\n _notify: notifySuccess,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n // Error notify state, moves a promise to the error state and notifies all children\n //\n state_error_notify = {\n name: \"error_notify\",\n enter: function (promise) {\n promise.done = ErrorPromise.prototype.done;\n promise.then = ErrorPromise.prototype.then;\n if (promise._listeners) {\n var queue = [promise];\n var p;\n while (queue.length) {\n p = queue.shift();\n p._state._notify(p, queue);\n }\n }\n promise._setState(state_error);\n },\n cancel: _,\n done: null, /*error to get here*/\n then: null, /*error to get here*/\n _completed: _,\n _error: _,\n _notify: notifyError,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n // Error state, moves a promise to the error state and does NOT notify any children.\n // Some upstream promise is owning the notification pass.\n //\n state_error = {\n name: \"error\",\n enter: function (promise) {\n promise.done = ErrorPromise.prototype.done;\n promise.then = ErrorPromise.prototype.then;\n promise._cleanupAction();\n },\n cancel: _,\n done: null, /*error to get here*/\n then: null, /*error to get here*/\n _completed: _,\n _error: _,\n _notify: notifyError,\n _progress: _,\n _setCompleteValue: _,\n _setErrorValue: _\n };\n\n //\n // The statemachine implementation follows a very particular pattern, the states are specified\n // as static stateless bags of functions which are then indirected through the state machine\n // instance (a Promise). As such all of the functions on each state have the promise instance\n // passed to them explicitly as a parameter and the Promise instance members do a little\n // dance where they indirect through the state and insert themselves in the argument list.\n //\n // We could instead call directly through the promise states however then every caller\n // would have to remember to do things like pumping the state machine to catch state transitions.\n //\n\n var PromiseStateMachine = _Base.Class.define(null, {\n _listeners: null,\n _nextState: null,\n _state: null,\n _value: null,\n\n cancel: function () {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.cancel\">\n /// <summary locid=\"WinJS.PromiseStateMachine.cancel\">\n /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't\n /// already been fulfilled and cancellation is supported, the promise enters\n /// the error state with a value of Error(\"Canceled\").\n /// </summary>\n /// </signature>\n this._state.cancel(this);\n this._run();\n },\n done: function Promise_done(onComplete, onError, onProgress) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.done\">\n /// <summary locid=\"WinJS.PromiseStateMachine.done\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n ///\n /// After the handlers have finished executing, this function throws any error that would have been returned\n /// from then() as a promise in the error state.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.done_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The fulfilled value is passed as the single argument. If the value is null,\n /// the fulfilled value is returned. The value returned\n /// from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while executing the function, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function is the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onProgress\">\n /// the function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// </signature>\n this._state.done(this, onComplete, onError, onProgress);\n },\n then: function Promise_then(onComplete, onError, onProgress) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.then\">\n /// <summary locid=\"WinJS.PromiseStateMachine.then\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.then_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The value is passed as the single argument. If the value is null, the value is returned.\n /// The value returned from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while this function is being executed, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function becomes the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onProgress\">\n /// The function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.PromiseStateMachine.then_returnValue\">\n /// The promise whose value is the result of executing the complete or\n /// error function.\n /// </returns>\n /// </signature>\n return this._state.then(this, onComplete, onError, onProgress);\n },\n\n _chainedError: function (value, context) {\n var result = this._state._error(this, value, detailsForChainedError, context);\n this._run();\n return result;\n },\n _completed: function (value) {\n var result = this._state._completed(this, value);\n this._run();\n return result;\n },\n _error: function (value) {\n var result = this._state._error(this, value, detailsForError);\n this._run();\n return result;\n },\n _progress: function (value) {\n this._state._progress(this, value);\n },\n _setState: function (state) {\n this._nextState = state;\n },\n _setCompleteValue: function (value) {\n this._state._setCompleteValue(this, value);\n this._run();\n },\n _setChainedErrorValue: function (value, context) {\n var result = this._state._setErrorValue(this, value, detailsForChainedError, context);\n this._run();\n return result;\n },\n _setExceptionValue: function (value) {\n var result = this._state._setErrorValue(this, value, detailsForException);\n this._run();\n return result;\n },\n _run: function () {\n while (this._nextState) {\n this._state = this._nextState;\n this._nextState = null;\n this._state.enter(this);\n }\n }\n }, {\n supportedForProcessing: false\n });\n\n //\n // Implementations of shared state machine code.\n //\n\n function completed(promise, value) {\n var targetState;\n if (value && typeof value === \"object\" && typeof value.then === \"function\") {\n targetState = state_waiting;\n } else {\n targetState = state_success_notify;\n }\n promise._value = value;\n promise._setState(targetState);\n }\n function createErrorDetails(exception, error, promise, id, parent, handler) {\n return {\n exception: exception,\n error: error,\n promise: promise,\n handler: handler,\n id: id,\n parent: parent\n };\n }\n function detailsForHandledError(promise, errorValue, context, handler) {\n var exception = context._isException;\n var errorId = context._errorId;\n return createErrorDetails(\n exception ? errorValue : null,\n exception ? null : errorValue,\n promise,\n errorId,\n context,\n handler\n );\n }\n function detailsForChainedError(promise, errorValue, context) {\n var exception = context._isException;\n var errorId = context._errorId;\n setErrorInfo(promise, errorId, exception);\n return createErrorDetails(\n exception ? errorValue : null,\n exception ? null : errorValue,\n promise,\n errorId,\n context\n );\n }\n function detailsForError(promise, errorValue) {\n var errorId = ++error_number;\n setErrorInfo(promise, errorId);\n return createErrorDetails(\n null,\n errorValue,\n promise,\n errorId\n );\n }\n function detailsForException(promise, exceptionValue) {\n var errorId = ++error_number;\n setErrorInfo(promise, errorId, true);\n return createErrorDetails(\n exceptionValue,\n null,\n promise,\n errorId\n );\n }\n function done(promise, onComplete, onError, onProgress) {\n var asyncOpID = _Trace._traceAsyncOperationStarting(\"WinJS.Promise.done\");\n pushListener(promise, { c: onComplete, e: onError, p: onProgress, asyncOpID: asyncOpID });\n }\n function error(promise, value, onerrorDetails, context) {\n promise._value = value;\n callonerror(promise, value, onerrorDetails, context);\n promise._setState(state_error_notify);\n }\n function notifySuccess(promise, queue) {\n var value = promise._value;\n var listeners = promise._listeners;\n if (!listeners) {\n return;\n }\n promise._listeners = null;\n var i, len;\n for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {\n var listener = len === 1 ? listeners : listeners[i];\n var onComplete = listener.c;\n var target = listener.promise;\n\n _Trace._traceAsyncOperationCompleted(listener.asyncOpID, _Global.Debug && _Global.Debug.MS_ASYNC_OP_STATUS_SUCCESS);\n\n if (target) {\n _Trace._traceAsyncCallbackStarting(listener.asyncOpID);\n try {\n target._setCompleteValue(onComplete ? onComplete(value) : value);\n } catch (ex) {\n target._setExceptionValue(ex);\n } finally {\n _Trace._traceAsyncCallbackCompleted();\n }\n if (target._state !== state_waiting && target._listeners) {\n queue.push(target);\n }\n } else {\n CompletePromise.prototype.done.call(promise, onComplete);\n }\n }\n }\n function notifyError(promise, queue) {\n var value = promise._value;\n var listeners = promise._listeners;\n if (!listeners) {\n return;\n }\n promise._listeners = null;\n var i, len;\n for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {\n var listener = len === 1 ? listeners : listeners[i];\n var onError = listener.e;\n var target = listener.promise;\n\n var errorID = _Global.Debug && (value && value.name === canceledName ? _Global.Debug.MS_ASYNC_OP_STATUS_CANCELED : _Global.Debug.MS_ASYNC_OP_STATUS_ERROR);\n _Trace._traceAsyncOperationCompleted(listener.asyncOpID, errorID);\n\n if (target) {\n var asyncCallbackStarted = false;\n try {\n if (onError) {\n _Trace._traceAsyncCallbackStarting(listener.asyncOpID);\n asyncCallbackStarted = true;\n if (!onError.handlesOnError) {\n callonerror(target, value, detailsForHandledError, promise, onError);\n }\n target._setCompleteValue(onError(value));\n } else {\n target._setChainedErrorValue(value, promise);\n }\n } catch (ex) {\n target._setExceptionValue(ex);\n } finally {\n if (asyncCallbackStarted) {\n _Trace._traceAsyncCallbackCompleted();\n }\n }\n if (target._state !== state_waiting && target._listeners) {\n queue.push(target);\n }\n } else {\n ErrorPromise.prototype.done.call(promise, null, onError);\n }\n }\n }\n function callonerror(promise, value, onerrorDetailsGenerator, context, handler) {\n if (promiseEventListeners._listeners[errorET]) {\n if (value instanceof Error && value.message === canceledName) {\n return;\n }\n promiseEventListeners.dispatchEvent(errorET, onerrorDetailsGenerator(promise, value, context, handler));\n }\n }\n function progress(promise, value) {\n var listeners = promise._listeners;\n if (listeners) {\n var i, len;\n for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {\n var listener = len === 1 ? listeners : listeners[i];\n var onProgress = listener.p;\n if (onProgress) {\n try { onProgress(value); } catch (ex) { }\n }\n if (!(listener.c || listener.e) && listener.promise) {\n listener.promise._progress(value);\n }\n }\n }\n }\n function pushListener(promise, listener) {\n var listeners = promise._listeners;\n if (listeners) {\n // We may have either a single listener (which will never be wrapped in an array)\n // or 2+ listeners (which will be wrapped). Since we are now adding one more listener\n // we may have to wrap the single listener before adding the second.\n listeners = Array.isArray(listeners) ? listeners : [listeners];\n listeners.push(listener);\n } else {\n listeners = listener;\n }\n promise._listeners = listeners;\n }\n // The difference beween setCompleteValue()/setErrorValue() and complete()/error() is that setXXXValue() moves\n // a promise directly to the success/error state without starting another notification pass (because one\n // is already ongoing).\n function setErrorInfo(promise, errorId, isException) {\n promise._isException = isException || false;\n promise._errorId = errorId;\n }\n function setErrorValue(promise, value, onerrorDetails, context) {\n promise._value = value;\n callonerror(promise, value, onerrorDetails, context);\n promise._setState(state_error);\n }\n function setCompleteValue(promise, value) {\n var targetState;\n if (value && typeof value === \"object\" && typeof value.then === \"function\") {\n targetState = state_waiting;\n } else {\n targetState = state_success;\n }\n promise._value = value;\n promise._setState(targetState);\n }\n function then(promise, onComplete, onError, onProgress) {\n var result = new ThenPromise(promise);\n var asyncOpID = _Trace._traceAsyncOperationStarting(\"WinJS.Promise.then\");\n pushListener(promise, { promise: result, c: onComplete, e: onError, p: onProgress, asyncOpID: asyncOpID });\n return result;\n }\n\n //\n // Internal implementation detail promise, ThenPromise is created when a promise needs\n // to be returned from a then() method.\n //\n var ThenPromise = _Base.Class.derive(PromiseStateMachine,\n function (creator) {\n\n if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.thenPromise))) {\n this._stack = Promise._getStack();\n }\n\n this._creator = creator;\n this._setState(state_created);\n this._run();\n }, {\n _creator: null,\n\n _cancelAction: function () { if (this._creator) { this._creator.cancel(); } },\n _cleanupAction: function () { this._creator = null; }\n }, {\n supportedForProcessing: false\n }\n );\n\n //\n // Slim promise implementations for already completed promises, these are created\n // under the hood on synchronous completion paths as well as by WinJS.Promise.wrap\n // and WinJS.Promise.wrapError.\n //\n\n var ErrorPromise = _Base.Class.define(\n function ErrorPromise_ctor(value) {\n\n if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.errorPromise))) {\n this._stack = Promise._getStack();\n }\n\n this._value = value;\n callonerror(this, value, detailsForError);\n }, {\n cancel: function () {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.cancel\">\n /// <summary locid=\"WinJS.PromiseStateMachine.cancel\">\n /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't\n /// already been fulfilled and cancellation is supported, the promise enters\n /// the error state with a value of Error(\"Canceled\").\n /// </summary>\n /// </signature>\n },\n done: function ErrorPromise_done(unused, onError) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.done\">\n /// <summary locid=\"WinJS.PromiseStateMachine.done\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n ///\n /// After the handlers have finished executing, this function throws any error that would have been returned\n /// from then() as a promise in the error state.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.done_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The fulfilled value is passed as the single argument. If the value is null,\n /// the fulfilled value is returned. The value returned\n /// from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while executing the function, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function is the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onProgress\">\n /// the function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// </signature>\n var value = this._value;\n if (onError) {\n try {\n if (!onError.handlesOnError) {\n callonerror(null, value, detailsForHandledError, this, onError);\n }\n var result = onError(value);\n if (result && typeof result === \"object\" && typeof result.done === \"function\") {\n // If a promise is returned we need to wait on it.\n result.done();\n }\n return;\n } catch (ex) {\n value = ex;\n }\n }\n if (value instanceof Error && value.message === canceledName) {\n // suppress cancel\n return;\n }\n // force the exception to be thrown asyncronously to avoid any try/catch blocks\n //\n Promise._doneHandler(value);\n },\n then: function ErrorPromise_then(unused, onError) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.then\">\n /// <summary locid=\"WinJS.PromiseStateMachine.then\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.then_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The value is passed as the single argument. If the value is null, the value is returned.\n /// The value returned from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while this function is being executed, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function becomes the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onProgress\">\n /// The function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.PromiseStateMachine.then_returnValue\">\n /// The promise whose value is the result of executing the complete or\n /// error function.\n /// </returns>\n /// </signature>\n\n // If the promise is already in a error state and no error handler is provided\n // we optimize by simply returning the promise instead of creating a new one.\n //\n if (!onError) { return this; }\n var result;\n var value = this._value;\n try {\n if (!onError.handlesOnError) {\n callonerror(null, value, detailsForHandledError, this, onError);\n }\n result = new CompletePromise(onError(value));\n } catch (ex) {\n // If the value throw from the error handler is the same as the value\n // provided to the error handler then there is no need for a new promise.\n //\n if (ex === value) {\n result = this;\n } else {\n result = new ExceptionPromise(ex);\n }\n }\n return result;\n }\n }, {\n supportedForProcessing: false\n }\n );\n\n var ExceptionPromise = _Base.Class.derive(ErrorPromise,\n function ExceptionPromise_ctor(value) {\n\n if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.exceptionPromise))) {\n this._stack = Promise._getStack();\n }\n\n this._value = value;\n callonerror(this, value, detailsForException);\n }, {\n /* empty */\n }, {\n supportedForProcessing: false\n }\n );\n\n var CompletePromise = _Base.Class.define(\n function CompletePromise_ctor(value) {\n\n if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.completePromise))) {\n this._stack = Promise._getStack();\n }\n\n if (value && typeof value === \"object\" && typeof value.then === \"function\") {\n var result = new ThenPromise(null);\n result._setCompleteValue(value);\n return result;\n }\n this._value = value;\n }, {\n cancel: function () {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.cancel\">\n /// <summary locid=\"WinJS.PromiseStateMachine.cancel\">\n /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't\n /// already been fulfilled and cancellation is supported, the promise enters\n /// the error state with a value of Error(\"Canceled\").\n /// </summary>\n /// </signature>\n },\n done: function CompletePromise_done(onComplete) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.done\">\n /// <summary locid=\"WinJS.PromiseStateMachine.done\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n ///\n /// After the handlers have finished executing, this function throws any error that would have been returned\n /// from then() as a promise in the error state.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.done_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The fulfilled value is passed as the single argument. If the value is null,\n /// the fulfilled value is returned. The value returned\n /// from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while executing the function, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function is the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.done_p:onProgress\">\n /// the function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// </signature>\n if (!onComplete) { return; }\n try {\n var result = onComplete(this._value);\n if (result && typeof result === \"object\" && typeof result.done === \"function\") {\n result.done();\n }\n } catch (ex) {\n // force the exception to be thrown asynchronously to avoid any try/catch blocks\n Promise._doneHandler(ex);\n }\n },\n then: function CompletePromise_then(onComplete) {\n /// <signature helpKeyword=\"WinJS.PromiseStateMachine.then\">\n /// <summary locid=\"WinJS.PromiseStateMachine.then\">\n /// Allows you to specify the work to be done on the fulfillment of the promised value,\n /// the error handling to be performed if the promise fails to fulfill\n /// a value, and the handling of progress notifications along the way.\n /// </summary>\n /// <param name='onComplete' type='Function' locid=\"WinJS.PromiseStateMachine.then_p:onComplete\">\n /// The function to be called if the promise is fulfilled successfully with a value.\n /// The value is passed as the single argument. If the value is null, the value is returned.\n /// The value returned from the function becomes the fulfilled value of the promise returned by\n /// then(). If an exception is thrown while this function is being executed, the promise returned\n /// by then() moves into the error state.\n /// </param>\n /// <param name='onError' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onError\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument. If it is null, the error is forwarded.\n /// The value returned from the function becomes the fulfilled value of the promise returned by then().\n /// </param>\n /// <param name='onProgress' type='Function' optional='true' locid=\"WinJS.PromiseStateMachine.then_p:onProgress\">\n /// The function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.PromiseStateMachine.then_returnValue\">\n /// The promise whose value is the result of executing the complete or\n /// error function.\n /// </returns>\n /// </signature>\n try {\n // If the value returned from the completion handler is the same as the value\n // provided to the completion handler then there is no need for a new promise.\n //\n var newValue = onComplete ? onComplete(this._value) : this._value;\n return newValue === this._value ? this : new CompletePromise(newValue);\n } catch (ex) {\n return new ExceptionPromise(ex);\n }\n }\n }, {\n supportedForProcessing: false\n }\n );\n\n //\n // Promise is the user-creatable WinJS.Promise object.\n //\n\n function timeout(timeoutMS) {\n var id;\n return new Promise(\n function (c) {\n if (timeoutMS) {\n id = _Global.setTimeout(c, timeoutMS);\n } else {\n _BaseCoreUtils._setImmediate(c);\n }\n },\n function () {\n if (id) {\n _Global.clearTimeout(id);\n }\n }\n );\n }\n\n function timeoutWithPromise(timeout, promise) {\n var cancelPromise = function () { promise.cancel(); };\n var cancelTimeout = function () { timeout.cancel(); };\n timeout.then(cancelPromise);\n promise.then(cancelTimeout, cancelTimeout);\n return promise;\n }\n\n var staticCanceledPromise;\n\n var Promise = _Base.Class.derive(PromiseStateMachine,\n function Promise_ctor(init, oncancel) {\n /// <signature helpKeyword=\"WinJS.Promise\">\n /// <summary locid=\"WinJS.Promise\">\n /// A promise provides a mechanism to schedule work to be done on a value that\n /// has not yet been computed. It is a convenient abstraction for managing\n /// interactions with asynchronous APIs.\n /// </summary>\n /// <param name=\"init\" type=\"Function\" locid=\"WinJS.Promise_p:init\">\n /// The function that is called during construction of the promise. The function\n /// is given three arguments (complete, error, progress). Inside this function\n /// you should add event listeners for the notifications supported by this value.\n /// </param>\n /// <param name=\"oncancel\" optional=\"true\" locid=\"WinJS.Promise_p:oncancel\">\n /// The function to call if a consumer of this promise wants\n /// to cancel its undone work. Promises are not required to\n /// support cancellation.\n /// </param>\n /// </signature>\n\n if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.promise))) {\n this._stack = Promise._getStack();\n }\n\n this._oncancel = oncancel;\n this._setState(state_created);\n this._run();\n\n try {\n var complete = this._completed.bind(this);\n var error = this._error.bind(this);\n var progress = this._progress.bind(this);\n init(complete, error, progress);\n } catch (ex) {\n this._setExceptionValue(ex);\n }\n }, {\n _oncancel: null,\n\n _cancelAction: function () {\n // BEGIN monaco change\n try {\n if (this._oncancel) {\n this._oncancel();\n } else {\n throw new Error('Promise did not implement oncancel');\n }\n } catch (ex) {\n // Access fields to get them created\n var msg = ex.message;\n var stack = ex.stack;\n promiseEventListeners.dispatchEvent('error', ex);\n }\n // END monaco change\n },\n _cleanupAction: function () { this._oncancel = null; }\n }, {\n\n addEventListener: function Promise_addEventListener(eventType, listener, capture) {\n /// <signature helpKeyword=\"WinJS.Promise.addEventListener\">\n /// <summary locid=\"WinJS.Promise.addEventListener\">\n /// Adds an event listener to the control.\n /// </summary>\n /// <param name=\"eventType\" locid=\"WinJS.Promise.addEventListener_p:eventType\">\n /// The type (name) of the event.\n /// </param>\n /// <param name=\"listener\" locid=\"WinJS.Promise.addEventListener_p:listener\">\n /// The listener to invoke when the event is raised.\n /// </param>\n /// <param name=\"capture\" locid=\"WinJS.Promise.addEventListener_p:capture\">\n /// Specifies whether or not to initiate capture.\n /// </param>\n /// </signature>\n promiseEventListeners.addEventListener(eventType, listener, capture);\n },\n any: function Promise_any(values) {\n /// <signature helpKeyword=\"WinJS.Promise.any\">\n /// <summary locid=\"WinJS.Promise.any\">\n /// Returns a promise that is fulfilled when one of the input promises\n /// has been fulfilled.\n /// </summary>\n /// <param name=\"values\" type=\"Array\" locid=\"WinJS.Promise.any_p:values\">\n /// An array that contains promise objects or objects whose property\n /// values include promise objects.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.any_returnValue\">\n /// A promise that on fulfillment yields the value of the input (complete or error).\n /// </returns>\n /// </signature>\n return new Promise(\n function (complete, error) {\n var keys = Object.keys(values);\n if (keys.length === 0) {\n complete();\n }\n var canceled = 0;\n keys.forEach(function (key) {\n Promise.as(values[key]).then(\n function () { complete({ key: key, value: values[key] }); },\n function (e) {\n if (e instanceof Error && e.name === canceledName) {\n if ((++canceled) === keys.length) {\n complete(Promise.cancel);\n }\n return;\n }\n error({ key: key, value: values[key] });\n }\n );\n });\n },\n function () {\n var keys = Object.keys(values);\n keys.forEach(function (key) {\n var promise = Promise.as(values[key]);\n if (typeof promise.cancel === \"function\") {\n promise.cancel();\n }\n });\n }\n );\n },\n as: function Promise_as(value) {\n /// <signature helpKeyword=\"WinJS.Promise.as\">\n /// <summary locid=\"WinJS.Promise.as\">\n /// Returns a promise. If the object is already a promise it is returned;\n /// otherwise the object is wrapped in a promise.\n /// </summary>\n /// <param name=\"value\" locid=\"WinJS.Promise.as_p:value\">\n /// The value to be treated as a promise.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.as_returnValue\">\n /// A promise.\n /// </returns>\n /// </signature>\n if (value && typeof value === \"object\" && typeof value.then === \"function\") {\n return value;\n }\n return new CompletePromise(value);\n },\n /// <field type=\"WinJS.Promise\" helpKeyword=\"WinJS.Promise.cancel\" locid=\"WinJS.Promise.cancel\">\n /// Canceled promise value, can be returned from a promise completion handler\n /// to indicate cancelation of the promise chain.\n /// </field>\n cancel: {\n get: function () {\n return (staticCanceledPromise = staticCanceledPromise || new ErrorPromise(new _ErrorFromName(canceledName)));\n }\n },\n dispatchEvent: function Promise_dispatchEvent(eventType, details) {\n /// <signature helpKeyword=\"WinJS.Promise.dispatchEvent\">\n /// <summary locid=\"WinJS.Promise.dispatchEvent\">\n /// Raises an event of the specified type and properties.\n /// </summary>\n /// <param name=\"eventType\" locid=\"WinJS.Promise.dispatchEvent_p:eventType\">\n /// The type (name) of the event.\n /// </param>\n /// <param name=\"details\" locid=\"WinJS.Promise.dispatchEvent_p:details\">\n /// The set of additional properties to be attached to the event object.\n /// </param>\n /// <returns type=\"Boolean\" locid=\"WinJS.Promise.dispatchEvent_returnValue\">\n /// Specifies whether preventDefault was called on the event.\n /// </returns>\n /// </signature>\n return promiseEventListeners.dispatchEvent(eventType, details);\n },\n is: function Promise_is(value) {\n /// <signature helpKeyword=\"WinJS.Promise.is\">\n /// <summary locid=\"WinJS.Promise.is\">\n /// Determines whether a value fulfills the promise contract.\n /// </summary>\n /// <param name=\"value\" locid=\"WinJS.Promise.is_p:value\">\n /// A value that may be a promise.\n /// </param>\n /// <returns type=\"Boolean\" locid=\"WinJS.Promise.is_returnValue\">\n /// true if the specified value is a promise, otherwise false.\n /// </returns>\n /// </signature>\n return value && typeof value === \"object\" && typeof value.then === \"function\";\n },\n join: function Promise_join(values) {\n /// <signature helpKeyword=\"WinJS.Promise.join\">\n /// <summary locid=\"WinJS.Promise.join\">\n /// Creates a promise that is fulfilled when all the values are fulfilled.\n /// </summary>\n /// <param name=\"values\" type=\"Object\" locid=\"WinJS.Promise.join_p:values\">\n /// An object whose fields contain values, some of which may be promises.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.join_returnValue\">\n /// A promise whose value is an object with the same field names as those of the object in the values parameter, where\n /// each field value is the fulfilled value of a promise.\n /// </returns>\n /// </signature>\n return new Promise(\n function (complete, error, progress) {\n var keys = Object.keys(values);\n var errors = Array.isArray(values) ? [] : {};\n var results = Array.isArray(values) ? [] : {};\n var undefineds = 0;\n var pending = keys.length;\n var argDone = function (key) {\n if ((--pending) === 0) {\n var errorCount = Object.keys(errors).length;\n if (errorCount === 0) {\n complete(results);\n } else {\n var canceledCount = 0;\n keys.forEach(function (key) {\n var e = errors[key];\n if (e instanceof Error && e.name === canceledName) {\n canceledCount++;\n }\n });\n if (canceledCount === errorCount) {\n complete(Promise.cancel);\n } else {\n error(errors);\n }\n }\n } else {\n progress({ Key: key, Done: true });\n }\n };\n keys.forEach(function (key) {\n var value = values[key];\n if (value === undefined) {\n undefineds++;\n } else {\n Promise.then(value,\n function (value) { results[key] = value; argDone(key); },\n function (value) { errors[key] = value; argDone(key); }\n );\n }\n });\n pending -= undefineds;\n if (pending === 0) {\n complete(results);\n return;\n }\n },\n function () {\n Object.keys(values).forEach(function (key) {\n var promise = Promise.as(values[key]);\n if (typeof promise.cancel === \"function\") {\n promise.cancel();\n }\n });\n }\n );\n },\n removeEventListener: function Promise_removeEventListener(eventType, listener, capture) {\n /// <signature helpKeyword=\"WinJS.Promise.removeEventListener\">\n /// <summary locid=\"WinJS.Promise.removeEventListener\">\n /// Removes an event listener from the control.\n /// </summary>\n /// <param name='eventType' locid=\"WinJS.Promise.removeEventListener_eventType\">\n /// The type (name) of the event.\n /// </param>\n /// <param name='listener' locid=\"WinJS.Promise.removeEventListener_listener\">\n /// The listener to remove.\n /// </param>\n /// <param name='capture' locid=\"WinJS.Promise.removeEventListener_capture\">\n /// Specifies whether or not to initiate capture.\n /// </param>\n /// </signature>\n promiseEventListeners.removeEventListener(eventType, listener, capture);\n },\n supportedForProcessing: false,\n then: function Promise_then(value, onComplete, onError, onProgress) {\n /// <signature helpKeyword=\"WinJS.Promise.then\">\n /// <summary locid=\"WinJS.Promise.then\">\n /// A static version of the promise instance method then().\n /// </summary>\n /// <param name=\"value\" locid=\"WinJS.Promise.then_p:value\">\n /// the value to be treated as a promise.\n /// </param>\n /// <param name=\"onComplete\" type=\"Function\" locid=\"WinJS.Promise.then_p:complete\">\n /// The function to be called if the promise is fulfilled with a value.\n /// If it is null, the promise simply\n /// returns the value. The value is passed as the single argument.\n /// </param>\n /// <param name=\"onError\" type=\"Function\" optional=\"true\" locid=\"WinJS.Promise.then_p:error\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument.\n /// </param>\n /// <param name=\"onProgress\" type=\"Function\" optional=\"true\" locid=\"WinJS.Promise.then_p:progress\">\n /// The function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.then_returnValue\">\n /// A promise whose value is the result of executing the provided complete function.\n /// </returns>\n /// </signature>\n return Promise.as(value).then(onComplete, onError, onProgress);\n },\n thenEach: function Promise_thenEach(values, onComplete, onError, onProgress) {\n /// <signature helpKeyword=\"WinJS.Promise.thenEach\">\n /// <summary locid=\"WinJS.Promise.thenEach\">\n /// Performs an operation on all the input promises and returns a promise\n /// that has the shape of the input and contains the result of the operation\n /// that has been performed on each input.\n /// </summary>\n /// <param name=\"values\" locid=\"WinJS.Promise.thenEach_p:values\">\n /// A set of values (which could be either an array or an object) of which some or all are promises.\n /// </param>\n /// <param name=\"onComplete\" type=\"Function\" locid=\"WinJS.Promise.thenEach_p:complete\">\n /// The function to be called if the promise is fulfilled with a value.\n /// If the value is null, the promise returns the value.\n /// The value is passed as the single argument.\n /// </param>\n /// <param name=\"onError\" type=\"Function\" optional=\"true\" locid=\"WinJS.Promise.thenEach_p:error\">\n /// The function to be called if the promise is fulfilled with an error. The error\n /// is passed as the single argument.\n /// </param>\n /// <param name=\"onProgress\" type=\"Function\" optional=\"true\" locid=\"WinJS.Promise.thenEach_p:progress\">\n /// The function to be called if the promise reports progress. Data about the progress\n /// is passed as the single argument. Promises are not required to support\n /// progress.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.thenEach_returnValue\">\n /// A promise that is the result of calling Promise.join on the values parameter.\n /// </returns>\n /// </signature>\n var result = Array.isArray(values) ? [] : {};\n Object.keys(values).forEach(function (key) {\n result[key] = Promise.as(values[key]).then(onComplete, onError, onProgress);\n });\n return Promise.join(result);\n },\n timeout: function Promise_timeout(time, promise) {\n /// <signature helpKeyword=\"WinJS.Promise.timeout\">\n /// <summary locid=\"WinJS.Promise.timeout\">\n /// Creates a promise that is fulfilled after a timeout.\n /// </summary>\n /// <param name=\"timeout\" type=\"Number\" optional=\"true\" locid=\"WinJS.Promise.timeout_p:timeout\">\n /// The timeout period in milliseconds. If this value is zero or not specified\n /// setImmediate is called, otherwise setTimeout is called.\n /// </param>\n /// <param name=\"promise\" type=\"Promise\" optional=\"true\" locid=\"WinJS.Promise.timeout_p:promise\">\n /// A promise that will be canceled if it doesn't complete before the\n /// timeout has expired.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.timeout_returnValue\">\n /// A promise that is completed asynchronously after the specified timeout.\n /// </returns>\n /// </signature>\n var to = timeout(time);\n return promise ? timeoutWithPromise(to, promise) : to;\n },\n wrap: function Promise_wrap(value) {\n /// <signature helpKeyword=\"WinJS.Promise.wrap\">\n /// <summary locid=\"WinJS.Promise.wrap\">\n /// Wraps a non-promise value in a promise. You can use this function if you need\n /// to pass a value to a function that requires a promise.\n /// </summary>\n /// <param name=\"value\" locid=\"WinJS.Promise.wrap_p:value\">\n /// Some non-promise value to be wrapped in a promise.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.wrap_returnValue\">\n /// A promise that is successfully fulfilled with the specified value\n /// </returns>\n /// </signature>\n return new CompletePromise(value);\n },\n wrapError: function Promise_wrapError(error) {\n /// <signature helpKeyword=\"WinJS.Promise.wrapError\">\n /// <summary locid=\"WinJS.Promise.wrapError\">\n /// Wraps a non-promise error value in a promise. You can use this function if you need\n /// to pass an error to a function that requires a promise.\n /// </summary>\n /// <param name=\"error\" locid=\"WinJS.Promise.wrapError_p:error\">\n /// A non-promise error value to be wrapped in a promise.\n /// </param>\n /// <returns type=\"WinJS.Promise\" locid=\"WinJS.Promise.wrapError_returnValue\">\n /// A promise that is in an error state with the specified value.\n /// </returns>\n /// </signature>\n return new ErrorPromise(error);\n },\n\n _veryExpensiveTagWithStack: {\n get: function () { return tagWithStack; },\n set: function (value) { tagWithStack = value; }\n },\n _veryExpensiveTagWithStack_tag: tag,\n _getStack: function () {\n if (_Global.Debug && _Global.Debug.debuggerEnabled) {\n try { throw new Error(); } catch (e) { return e.stack; }\n }\n },\n\n _cancelBlocker: function Promise__cancelBlocker(input, oncancel) {\n //\n // Returns a promise which on cancelation will still result in downstream cancelation while\n // protecting the promise 'input' from being canceled which has the effect of allowing\n // 'input' to be shared amoung various consumers.\n //\n if (!Promise.is(input)) {\n return Promise.wrap(input);\n }\n var complete;\n var error;\n var output = new Promise(\n function (c, e) {\n complete = c;\n error = e;\n },\n function () {\n complete = null;\n error = null;\n oncancel && oncancel();\n }\n );\n input.then(\n function (v) { complete && complete(v); },\n function (e) { error && error(e); }\n );\n return output;\n },\n\n }\n );\n Object.defineProperties(Promise, _Events.createEventProperties(errorET));\n\n Promise._doneHandler = function (value) {\n _BaseCoreUtils._setImmediate(function Promise_done_rethrow() {\n throw value;\n });\n };\n\n return {\n PromiseStateMachine: PromiseStateMachine,\n Promise: Promise,\n state_created: state_created\n };\n});\n\n_winjs(\"WinJS/Promise\", [\"WinJS/Core/_Base\",\"WinJS/Promise/_StateMachine\"], function promiseInit( _Base, _StateMachine) {\n \"use strict\";\n\n _Base.Namespace.define(\"WinJS\", {\n Promise: _StateMachine.Promise\n });\n\n return _StateMachine.Promise;\n});\n\n__winjs_exports = _modules[\"WinJS/Core/_WinJS\"];\n__winjs_exports.TPromise = __winjs_exports.Promise;\n__winjs_exports.PPromise = __winjs_exports.Promise;\n\n// ESM-comment-begin\nif (typeof exports === 'undefined' && typeof define === 'function' && define.amd) {\n define(\"vs/base/common/winjs.base\", [], __winjs_exports);\n} else {\n module.exports = __winjs_exports;\n}\n// ESM-comment-end\n\n})();\n\n// ESM-uncomment-begin\n// export var Promise = __winjs_exports.Promise;\n// export var TPromise = __winjs_exports.TPromise;\n// export var PPromise = __winjs_exports.PPromise;\n// ESM-uncomment-end\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IAction } from 'vs/base/common/actions';\nimport { TPromise, IPromiseError, IPromiseErrorDetail } from 'vs/base/common/winjs.base';\n\n// ------ BEGIN Hook up error listeners to winjs promises\n\nlet outstandingPromiseErrors: { [id: string]: IPromiseErrorDetail; } = {};\nfunction promiseErrorHandler(e: IPromiseError): void {\n\n\t//\n\t// e.detail looks like: { exception, error, promise, handler, id, parent }\n\t//\n\tconst details = e.detail;\n\tconst id = details.id;\n\n\t// If the error has a parent promise then this is not the origination of the\n\t// error so we check if it has a handler, and if so we mark that the error\n\t// was handled by removing it from outstandingPromiseErrors\n\t//\n\tif (details.parent) {\n\t\tif (details.handler && outstandingPromiseErrors) {\n\t\t\tdelete outstandingPromiseErrors[id];\n\t\t}\n\t\treturn;\n\t}\n\n\t// Indicate that this error was originated and needs to be handled\n\toutstandingPromiseErrors[id] = details;\n\n\t// The first time the queue fills up this iteration, schedule a timeout to\n\t// check if any errors are still unhandled.\n\tif (Object.keys(outstandingPromiseErrors).length === 1) {\n\t\tsetTimeout(function () {\n\t\t\tconst errors = outstandingPromiseErrors;\n\t\t\toutstandingPromiseErrors = {};\n\t\t\tObject.keys(errors).forEach(function (errorId) {\n\t\t\t\tconst error = errors[errorId];\n\t\t\t\tif (error.exception) {\n\t\t\t\t\tonUnexpectedError(error.exception);\n\t\t\t\t} else if (error.error) {\n\t\t\t\t\tonUnexpectedError(error.error);\n\t\t\t\t}\n\t\t\t\tconsole.log('WARNING: Promise with no error callback:' + error.id);\n\t\t\t\tconsole.log(error);\n\t\t\t\tif (error.exception) {\n\t\t\t\t\tconsole.log(error.exception.stack);\n\t\t\t\t}\n\t\t\t});\n\t\t}, 0);\n\t}\n}\nTPromise.addEventListener('error', promiseErrorHandler);\n\n// ------ END Hook up error listeners to winjs promises\n\nexport interface ErrorListenerCallback {\n\t(error: any): void;\n}\n\nexport interface ErrorListenerUnbind {\n\t(): void;\n}\n\n// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nexport class ErrorHandler {\n\tprivate unexpectedErrorHandler: (e: any) => void;\n\tprivate listeners: ErrorListenerCallback[];\n\n\tconstructor() {\n\n\t\tthis.listeners = [];\n\n\t\tthis.unexpectedErrorHandler = function (e: any) {\n\t\t\tsetTimeout(() => {\n\t\t\t\tif (e.stack) {\n\t\t\t\t\tthrow new Error(e.message + '\\n\\n' + e.stack);\n\t\t\t\t}\n\n\t\t\t\tthrow e;\n\t\t\t}, 0);\n\t\t};\n\t}\n\n\tpublic addListener(listener: ErrorListenerCallback): ErrorListenerUnbind {\n\t\tthis.listeners.push(listener);\n\n\t\treturn () => {\n\t\t\tthis._removeListener(listener);\n\t\t};\n\t}\n\n\tprivate emit(e: any): void {\n\t\tthis.listeners.forEach((listener) => {\n\t\t\tlistener(e);\n\t\t});\n\t}\n\n\tprivate _removeListener(listener: ErrorListenerCallback): void {\n\t\tthis.listeners.splice(this.listeners.indexOf(listener), 1);\n\t}\n\n\tpublic setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {\n\t\tthis.unexpectedErrorHandler = newUnexpectedErrorHandler;\n\t}\n\n\tpublic getUnexpectedErrorHandler(): (e: any) => void {\n\t\treturn this.unexpectedErrorHandler;\n\t}\n\n\tpublic onUnexpectedError(e: any): void {\n\t\tthis.unexpectedErrorHandler(e);\n\t\tthis.emit(e);\n\t}\n\n\t// For external errors, we don't want the listeners to be called\n\tpublic onUnexpectedExternalError(e: any): void {\n\t\tthis.unexpectedErrorHandler(e);\n\t}\n}\n\nexport const errorHandler = new ErrorHandler();\n\nexport function setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {\n\terrorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler);\n}\n\nexport function onUnexpectedError(e: any): undefined {\n\t// ignore errors from cancelled promises\n\tif (!isPromiseCanceledError(e)) {\n\t\terrorHandler.onUnexpectedError(e);\n\t}\n\treturn undefined;\n}\n\nexport function onUnexpectedExternalError(e: any): undefined {\n\t// ignore errors from cancelled promises\n\tif (!isPromiseCanceledError(e)) {\n\t\terrorHandler.onUnexpectedExternalError(e);\n\t}\n\treturn undefined;\n}\n\nexport interface SerializedError {\n\treadonly $isError: true;\n\treadonly name: string;\n\treadonly message: string;\n\treadonly stack: string;\n}\n\nexport function transformErrorForSerialization(error: Error): SerializedError;\nexport function transformErrorForSerialization(error: any): any;\nexport function transformErrorForSerialization(error: any): any {\n\tif (error instanceof Error) {\n\t\tlet { name, message } = error;\n\t\tlet stack: string = (<any>error).stacktrace || (<any>error).stack;\n\t\treturn {\n\t\t\t$isError: true,\n\t\t\tname,\n\t\t\tmessage,\n\t\t\tstack\n\t\t};\n\t}\n\n\t// return as is\n\treturn error;\n}\n\n// see https://github.com/v8/v8/wiki/Stack%20Trace%20API#basic-stack-traces\nexport interface V8CallSite {\n\tgetThis(): any;\n\tgetTypeName(): string;\n\tgetFunction(): string;\n\tgetFunctionName(): string;\n\tgetMethodName(): string;\n\tgetFileName(): string;\n\tgetLineNumber(): number;\n\tgetColumnNumber(): number;\n\tgetEvalOrigin(): string;\n\tisToplevel(): boolean;\n\tisEval(): boolean;\n\tisNative(): boolean;\n\tisConstructor(): boolean;\n\ttoString(): string;\n}\n\nconst canceledName = 'Canceled';\n\n/**\n * Checks if the given error is a promise in canceled state\n */\nexport function isPromiseCanceledError(error: any): boolean {\n\treturn error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n\n/**\n * Returns an error that signals cancellation.\n */\nexport function canceled(): Error {\n\tlet error = new Error(canceledName);\n\terror.name = error.message;\n\treturn error;\n}\n\nexport function illegalArgument(name?: string): Error {\n\tif (name) {\n\t\treturn new Error(`Illegal argument: ${name}`);\n\t} else {\n\t\treturn new Error('Illegal argument');\n\t}\n}\n\nexport function illegalState(name?: string): Error {\n\tif (name) {\n\t\treturn new Error(`Illegal state: ${name}`);\n\t} else {\n\t\treturn new Error('Illegal state');\n\t}\n}\n\nexport function readonly(name?: string): Error {\n\treturn name\n\t\t? new Error(`readonly property '${name} cannot be changed'`)\n\t\t: new Error('readonly property cannot be changed');\n}\n\nexport function disposed(what: string): Error {\n\tconst result = new Error(`${what} has been disposed`);\n\tresult.name = 'DISPOSED';\n\treturn result;\n}\n\nexport interface IErrorOptions {\n\tactions?: IAction[];\n}\n\nexport interface IErrorWithActions {\n\tactions?: IAction[];\n}\n\nexport function isErrorWithActions(obj: any): obj is IErrorWithActions {\n\treturn obj instanceof Error && Array.isArray((obj as IErrorWithActions).actions);\n}\n\nexport function create(message: string, options: IErrorOptions = Object.create(null)): Error & IErrorWithActions {\n\tconst result = new Error(message);\n\n\tif (options.actions) {\n\t\t(<IErrorWithActions>result).actions = options.actions;\n\t}\n\n\treturn result;\n}\n\nexport function getErrorMessage(err: any): string {\n\tif (!err) {\n\t\treturn 'Error';\n\t}\n\n\tif (err.message) {\n\t\treturn err.message;\n\t}\n\n\tif (err.stack) {\n\t\treturn err.stack.split('\\n')[0];\n\t}\n\n\treturn String(err);\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IDisposable, toDisposable, combinedDisposable, empty as EmptyDisposable } from 'vs/base/common/lifecycle';\nimport { TPromise } from 'vs/base/common/winjs.base';\nimport { once as onceFn } from 'vs/base/common/functional';\nimport { onUnexpectedError } from 'vs/base/common/errors';\nimport { LinkedList } from 'vs/base/common/linkedList';\n\n/**\n * To an event a function with one or zero parameters\n * can be subscribed. The event is the subscriber function itself.\n */\nexport interface Event<T> {\n\t(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;\n}\n\nexport namespace Event {\n\tconst _disposable = { dispose() { } };\n\texport const None: Event<any> = function () { return _disposable; };\n}\n\ntype Listener = [Function, any] | Function;\n\nexport interface EmitterOptions {\n\tonFirstListenerAdd?: Function;\n\tonFirstListenerDidAdd?: Function;\n\tonListenerDidAdd?: Function;\n\tonLastListenerRemove?: Function;\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\tclass Document {\n\n\t\tprivate _onDidChange = new Emitter<(value:string)=>any>();\n\n\t\tpublic onDidChange = this._onDidChange.event;\n\n\t\t// getter-style\n\t\t// get onDidChange(): Event<(value:string)=>any> {\n\t\t// \treturn this._onDidChange.event;\n\t\t// }\n\n\t\tprivate _doIt() {\n\t\t\t//...\n\t\t\tthis._onDidChange.fire(value);\n\t\t}\n\t}\n */\nexport class Emitter<T> {\n\n\tprivate static readonly _noop = function () { };\n\n\tprivate _event: Event<T>;\n\tprivate _listeners: LinkedList<Listener>;\n\tprivate _deliveryQueue: [Listener, T][];\n\tprivate _disposed: boolean;\n\n\tconstructor(private _options?: EmitterOptions) {\n\n\t}\n\n\t/**\n\t * For the public to allow to subscribe\n\t * to events from this Emitter\n\t */\n\tget event(): Event<T> {\n\t\tif (!this._event) {\n\t\t\tthis._event = (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]) => {\n\t\t\t\tif (!this._listeners) {\n\t\t\t\t\tthis._listeners = new LinkedList();\n\t\t\t\t}\n\n\t\t\t\tconst firstListener = this._listeners.isEmpty();\n\n\t\t\t\tif (firstListener && this._options && this._options.onFirstListenerAdd) {\n\t\t\t\t\tthis._options.onFirstListenerAdd(this);\n\t\t\t\t}\n\n\t\t\t\tconst remove = this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\n\n\t\t\t\tif (firstListener && this._options && this._options.onFirstListenerDidAdd) {\n\t\t\t\t\tthis._options.onFirstListenerDidAdd(this);\n\t\t\t\t}\n\n\t\t\t\tif (this._options && this._options.onListenerDidAdd) {\n\t\t\t\t\tthis._options.onListenerDidAdd(this, listener, thisArgs);\n\t\t\t\t}\n\n\t\t\t\tlet result: IDisposable;\n\t\t\t\tresult = {\n\t\t\t\t\tdispose: () => {\n\t\t\t\t\t\tresult.dispose = Emitter._noop;\n\t\t\t\t\t\tif (!this._disposed) {\n\t\t\t\t\t\t\tremove();\n\t\t\t\t\t\t\tif (this._options && this._options.onLastListenerRemove && this._listeners.isEmpty()) {\n\t\t\t\t\t\t\t\tthis._options.onLastListenerRemove(this);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\tif (Array.isArray(disposables)) {\n\t\t\t\t\tdisposables.push(result);\n\t\t\t\t}\n\n\t\t\t\treturn result;\n\t\t\t};\n\t\t}\n\t\treturn this._event;\n\t}\n\n\t/**\n\t * To be kept private to fire an event to\n\t * subscribers\n\t */\n\tfire(event?: T): any {\n\t\tif (this._listeners) {\n\t\t\t// put all [listener,event]-pairs into delivery queue\n\t\t\t// then emit all event. an inner/nested event might be\n\t\t\t// the driver of this\n\n\t\t\tif (!this._deliveryQueue) {\n\t\t\t\tthis._deliveryQueue = [];\n\t\t\t}\n\n\t\t\tfor (let iter = this._listeners.iterator(), e = iter.next(); !e.done; e = iter.next()) {\n\t\t\t\tthis._deliveryQueue.push([e.value, event]);\n\t\t\t}\n\n\t\t\twhile (this._deliveryQueue.length > 0) {\n\t\t\t\tconst [listener, event] = this._deliveryQueue.shift();\n\t\t\t\ttry {\n\t\t\t\t\tif (typeof listener === 'function') {\n\t\t\t\t\t\tlistener.call(undefined, event);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tlistener[0].call(listener[1], event);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tonUnexpectedError(e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tdispose() {\n\t\tif (this._listeners) {\n\t\t\tthis._listeners = undefined;\n\t\t}\n\t\tif (this._deliveryQueue) {\n\t\t\tthis._deliveryQueue.length = 0;\n\t\t}\n\t\tthis._disposed = true;\n\t}\n}\n\nexport class EventMultiplexer<T> implements IDisposable {\n\n\tprivate readonly emitter: Emitter<T>;\n\tprivate hasListeners = false;\n\tprivate events: { event: Event<T>; listener: IDisposable; }[] = [];\n\n\tconstructor() {\n\t\tthis.emitter = new Emitter<T>({\n\t\t\tonFirstListenerAdd: () => this.onFirstListenerAdd(),\n\t\t\tonLastListenerRemove: () => this.onLastListenerRemove()\n\t\t});\n\t}\n\n\tget event(): Event<T> {\n\t\treturn this.emitter.event;\n\t}\n\n\tadd(event: Event<T>): IDisposable {\n\t\tconst e = { event: event, listener: null };\n\t\tthis.events.push(e);\n\n\t\tif (this.hasListeners) {\n\t\t\tthis.hook(e);\n\t\t}\n\n\t\tconst dispose = () => {\n\t\t\tif (this.hasListeners) {\n\t\t\t\tthis.unhook(e);\n\t\t\t}\n\n\t\t\tconst idx = this.events.indexOf(e);\n\t\t\tthis.events.splice(idx, 1);\n\t\t};\n\n\t\treturn toDisposable(onceFn(dispose));\n\t}\n\n\tprivate onFirstListenerAdd(): void {\n\t\tthis.hasListeners = true;\n\t\tthis.events.forEach(e => this.hook(e));\n\t}\n\n\tprivate onLastListenerRemove(): void {\n\t\tthis.hasListeners = false;\n\t\tthis.events.forEach(e => this.unhook(e));\n\t}\n\n\tprivate hook(e: { event: Event<T>; listener: IDisposable; }): void {\n\t\te.listener = e.event(r => this.emitter.fire(r));\n\t}\n\n\tprivate unhook(e: { event: Event<T>; listener: IDisposable; }): void {\n\t\te.listener.dispose();\n\t\te.listener = null;\n\t}\n\n\tdispose(): void {\n\t\tthis.emitter.dispose();\n\t}\n}\n\nexport function fromCallback<T>(fn: (handler: (e: T) => void) => IDisposable): Event<T> {\n\tlet listener: IDisposable;\n\n\tconst emitter = new Emitter<T>({\n\t\tonFirstListenerAdd: () => listener = fn(e => emitter.fire(e)),\n\t\tonLastListenerRemove: () => listener.dispose()\n\t});\n\n\treturn emitter.event;\n}\n\nexport function fromPromise<T =any>(promise: TPromise<T>): Event<T> {\n\tconst emitter = new Emitter<T>();\n\tlet shouldEmit = false;\n\n\tpromise\n\t\t.then(null, () => null)\n\t\t.then(() => {\n\t\t\tif (!shouldEmit) {\n\t\t\t\tsetTimeout(() => emitter.fire(), 0);\n\t\t\t} else {\n\t\t\t\temitter.fire();\n\t\t\t}\n\t\t});\n\n\tshouldEmit = true;\n\treturn emitter.event;\n}\n\nexport function toPromise<T>(event: Event<T>): TPromise<T> {\n\treturn new TPromise(complete => {\n\t\tconst sub = event(e => {\n\t\t\tsub.dispose();\n\t\t\tcomplete(e);\n\t\t});\n\t});\n}\n\nexport function once<T>(event: Event<T>): Event<T> {\n\treturn (listener, thisArgs = null, disposables?) => {\n\t\tconst result = event(e => {\n\t\t\tresult.dispose();\n\t\t\treturn listener.call(thisArgs, e);\n\t\t}, null, disposables);\n\n\t\treturn result;\n\t};\n}\n\nexport function anyEvent<T>(...events: Event<T>[]): Event<T> {\n\treturn (listener, thisArgs = null, disposables?) => combinedDisposable(events.map(event => event(e => listener.call(thisArgs, e), null, disposables)));\n}\n\nexport function debounceEvent<T>(event: Event<T>, merger: (last: T, event: T) => T, delay?: number, leading?: boolean): Event<T>;\nexport function debounceEvent<I, O>(event: Event<I>, merger: (last: O, event: I) => O, delay?: number, leading?: boolean): Event<O>;\nexport function debounceEvent<I, O>(event: Event<I>, merger: (last: O, event: I) => O, delay: number = 100, leading = false): Event<O> {\n\n\tlet subscription: IDisposable;\n\tlet output: O = undefined;\n\tlet handle: any = undefined;\n\tlet numDebouncedCalls = 0;\n\n\tconst emitter = new Emitter<O>({\n\t\tonFirstListenerAdd() {\n\t\t\tsubscription = event(cur => {\n\t\t\t\tnumDebouncedCalls++;\n\t\t\t\toutput = merger(output, cur);\n\n\t\t\t\tif (leading && !handle) {\n\t\t\t\t\temitter.fire(output);\n\t\t\t\t}\n\n\t\t\t\tclearTimeout(handle);\n\t\t\t\thandle = setTimeout(() => {\n\t\t\t\t\tlet _output = output;\n\t\t\t\t\toutput = undefined;\n\t\t\t\t\thandle = undefined;\n\t\t\t\t\tif (!leading || numDebouncedCalls > 1) {\n\t\t\t\t\t\temitter.fire(_output);\n\t\t\t\t\t}\n\n\t\t\t\t\tnumDebouncedCalls = 0;\n\t\t\t\t}, delay);\n\t\t\t});\n\t\t},\n\t\tonLastListenerRemove() {\n\t\t\tsubscription.dispose();\n\t\t}\n\t});\n\n\treturn emitter.event;\n}\n\n/**\n * The EventDelayer 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\n\tprivate buffers: Function[][] = [];\n\n\twrapEvent<T>(event: Event<T>): Event<T> {\n\t\treturn (listener, thisArgs?, disposables?) => {\n\t\t\treturn event(i => {\n\t\t\t\tconst buffer = this.buffers[this.buffers.length - 1];\n\n\t\t\t\tif (buffer) {\n\t\t\t\t\tbuffer.push(() => listener.call(thisArgs, i));\n\t\t\t\t} else {\n\t\t\t\t\tlistener.call(thisArgs, i);\n\t\t\t\t}\n\t\t\t}, void 0, disposables);\n\t\t};\n\t}\n\n\tbufferEvents(fn: () => void): void {\n\t\tconst buffer: Function[] = [];\n\t\tthis.buffers.push(buffer);\n\t\tfn();\n\t\tthis.buffers.pop();\n\t\tbuffer.forEach(flush => flush());\n\t}\n}\n\nexport interface IChainableEvent<T> {\n\tevent: Event<T>;\n\tmap<O>(fn: (i: T) => O): IChainableEvent<O>;\n\tforEach(fn: (i: T) => void): IChainableEvent<T>;\n\tfilter(fn: (e: T) => boolean): IChainableEvent<T>;\n\tlatch(): IChainableEvent<T>;\n\ton(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;\n}\n\nexport function mapEvent<I, O>(event: Event<I>, map: (i: I) => O): Event<O> {\n\treturn (listener, thisArgs = null, disposables?) => event(i => listener.call(thisArgs, map(i)), null, disposables);\n}\n\nexport function forEach<I>(event: Event<I>, each: (i: I) => void): Event<I> {\n\treturn (listener, thisArgs = null, disposables?) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables);\n}\n\nexport function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Event<T> {\n\treturn (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);\n}\n\nclass ChainableEvent<T> implements IChainableEvent<T> {\n\n\tget event(): Event<T> { return this._event; }\n\n\tconstructor(private _event: Event<T>) { }\n\n\tmap<O>(fn: (i: T) => O): IChainableEvent<O> {\n\t\treturn new ChainableEvent(mapEvent(this._event, fn));\n\t}\n\n\tforEach(fn: (i: T) => void): IChainableEvent<T> {\n\t\treturn new ChainableEvent(forEach(this._event, fn));\n\t}\n\n\tfilter(fn: (e: T) => boolean): IChainableEvent<T> {\n\t\treturn new ChainableEvent(filterEvent(this._event, fn));\n\t}\n\n\tlatch(): IChainableEvent<T> {\n\t\treturn new ChainableEvent(latch(this._event));\n\t}\n\n\ton(listener: (e: T) => any, thisArgs: any, disposables: IDisposable[]) {\n\t\treturn this._event(listener, thisArgs, disposables);\n\t}\n}\n\nexport function chain<T>(event: Event<T>): IChainableEvent<T> {\n\treturn new ChainableEvent(event);\n}\n\nexport function stopwatch<T>(event: Event<T>): Event<number> {\n\tconst start = new Date().getTime();\n\treturn mapEvent(once(event), _ => new Date().getTime() - start);\n}\n\n/**\n * Buffers the provided event until a first listener comes\n * along, at which point fire all the events at once and\n * pipe the event from then on.\n *\n * ```typescript\n * const emitter = new Emitter<number>();\n * const event = emitter.event;\n * const bufferedEvent = buffer(event);\n *\n * emitter.fire(1);\n * emitter.fire(2);\n * emitter.fire(3);\n * // nothing...\n *\n * const listener = bufferedEvent(num => console.log(num));\n * // 1, 2, 3\n *\n * emitter.fire(4);\n * // 4\n * ```\n */\nexport function buffer<T>(event: Event<T>, nextTick = false, buffer: T[] = []): Event<T> {\n\tbuffer = buffer.slice();\n\n\tlet listener = event(e => {\n\t\tif (buffer) {\n\t\t\tbuffer.push(e);\n\t\t} else {\n\t\t\temitter.fire(e);\n\t\t}\n\t});\n\n\tconst flush = () => {\n\t\tbuffer.forEach(e => emitter.fire(e));\n\t\tbuffer = null;\n\t};\n\n\tconst emitter = new Emitter<T>({\n\t\tonFirstListenerAdd() {\n\t\t\tif (!listener) {\n\t\t\t\tlistener = event(e => emitter.fire(e));\n\t\t\t}\n\t\t},\n\n\t\tonFirstListenerDidAdd() {\n\t\t\tif (buffer) {\n\t\t\t\tif (nextTick) {\n\t\t\t\t\tsetTimeout(flush);\n\t\t\t\t} else {\n\t\t\t\t\tflush();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tonLastListenerRemove() {\n\t\t\tlistener.dispose();\n\t\t\tlistener = null;\n\t\t}\n\t});\n\n\treturn emitter.event;\n}\n\n/**\n * Similar to `buffer` but it buffers indefinitely and repeats\n * the buffered events to every new listener.\n */\nexport function echo<T>(event: Event<T>, nextTick = false, buffer: T[] = []): Event<T> {\n\tbuffer = buffer.slice();\n\n\tevent(e => {\n\t\tbuffer.push(e);\n\t\temitter.fire(e);\n\t});\n\n\tconst flush = (listener: (e: T) => any, thisArgs?: any) => buffer.forEach(e => listener.call(thisArgs, e));\n\n\tconst emitter = new Emitter<T>({\n\t\tonListenerDidAdd(emitter, listener: (e: T) => any, thisArgs?: any) {\n\t\t\tif (nextTick) {\n\t\t\t\tsetTimeout(() => flush(listener, thisArgs));\n\t\t\t} else {\n\t\t\t\tflush(listener, thisArgs);\n\t\t\t}\n\t\t}\n\t});\n\n\treturn emitter.event;\n}\n\nexport class Relay<T> implements IDisposable {\n\n\tprivate emitter = new Emitter<T>();\n\treadonly event: Event<T> = this.emitter.event;\n\n\tprivate disposable: IDisposable = EmptyDisposable;\n\n\tset input(event: Event<T>) {\n\t\tthis.disposable.dispose();\n\t\tthis.disposable = event(this.emitter.fire, this.emitter);\n\t}\n\n\tdispose() {\n\t\tthis.disposable.dispose();\n\t\tthis.emitter.dispose();\n\t}\n}\n\nexport interface NodeEventEmitter {\n\ton(event: string | symbol, listener: Function): this;\n\tremoveListener(event: string | symbol, listener: Function): this;\n}\n\nexport function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map: (...args: any[]) => T = id => id): Event<T> {\n\tconst fn = (...args: any[]) => result.fire(map(...args));\n\tconst onFirstListenerAdd = () => emitter.on(eventName, fn);\n\tconst onLastListenerRemove = () => emitter.removeListener(eventName, fn);\n\tconst result = new Emitter<T>({ onFirstListenerAdd, onLastListenerRemove });\n\n\treturn result.event;\n}\n\nexport function latch<T>(event: Event<T>): Event<T> {\n\tlet firstCall = true;\n\tlet cache: T;\n\n\treturn filterEvent(event, value => {\n\t\tlet shouldEmit = firstCall || value !== cache;\n\t\tfirstCall = false;\n\t\tcache = value;\n\t\treturn shouldEmit;\n\t});\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'use strict';\n\nimport { Event, Emitter } from 'vs/base/common/event';\nimport { IDisposable } from 'vs/base/common/lifecycle';\n\nexport interface CancellationToken {\n\treadonly isCancellationRequested: boolean;\n\t/**\n\t * An event emitted when cancellation is requested\n\t * @event\n\t */\n\treadonly onCancellationRequested: Event<any>;\n}\n\nconst shortcutEvent = Object.freeze(function (callback, context?): IDisposable {\n\tlet handle = setTimeout(callback.bind(context), 0);\n\treturn { dispose() { clearTimeout(handle); } };\n} as Event<any>);\n\nexport namespace CancellationToken {\n\n\texport const None: CancellationToken = Object.freeze({\n\t\tisCancellationRequested: false,\n\t\tonCancellationRequested: Event.None\n\t});\n\n\texport const Cancelled: CancellationToken = Object.freeze({\n\t\tisCancellationRequested: true,\n\t\tonCancellationRequested: shortcutEvent\n\t});\n}\n\nclass MutableToken implements CancellationToken {\n\n\tprivate _isCancelled: boolean = false;\n\tprivate _emitter: Emitter<any>;\n\n\tpublic cancel() {\n\t\tif (!this._isCancelled) {\n\t\t\tthis._isCancelled = true;\n\t\t\tif (this._emitter) {\n\t\t\t\tthis._emitter.fire(undefined);\n\t\t\t\tthis.dispose();\n\t\t\t}\n\t\t}\n\t}\n\n\tget isCancellationRequested(): boolean {\n\t\treturn this._isCancelled;\n\t}\n\n\tget onCancellationRequested(): Event<any> {\n\t\tif (this._isCancelled) {\n\t\t\treturn shortcutEvent;\n\t\t}\n\t\tif (!this._emitter) {\n\t\t\tthis._emitter = new Emitter<any>();\n\t\t}\n\t\treturn this._emitter.event;\n\t}\n\n\tpublic dispose(): void {\n\t\tif (this._emitter) {\n\t\t\tthis._emitter.dispose();\n\t\t\tthis._emitter = undefined;\n\t\t}\n\t}\n}\n\nexport class CancellationTokenSource {\n\n\tprivate _token: CancellationToken;\n\n\tget token(): CancellationToken {\n\t\tif (!this._token) {\n\t\t\t// be lazy and create the token only when\n\t\t\t// actually needed\n\t\t\tthis._token = new MutableToken();\n\t\t}\n\t\treturn this._token;\n\t}\n\n\tcancel(): void {\n\t\tif (!this._token) {\n\t\t\t// save an object by returning the default\n\t\t\t// cancelled token when cancellation happens\n\t\t\t// before someone asks for the token\n\t\t\tthis._token = CancellationToken.Cancelled;\n\n\t\t} else if (this._token instanceof MutableToken) {\n\t\t\t// actually cancel\n\t\t\tthis._token.cancel();\n\t\t}\n\t}\n\n\tdispose(): void {\n\t\tif (!this._token) {\n\t\t\t// ensure to initialize with an empty token if we had none\n\t\t\tthis._token = CancellationToken.None;\n\n\t\t} else if (this._token instanceof MutableToken) {\n\t\t\t// actually dispose\n\t\t\tthis._token.dispose();\n\t\t}\n\t}\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'use strict';\n\nimport * as errors from 'vs/base/common/errors';\nimport { Promise, TPromise, ValueCallback, ErrorCallback, ProgressCallback } from 'vs/base/common/winjs.base';\nimport { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';\nimport { Disposable, IDisposable } from 'vs/base/common/lifecycle';\nimport { Event, Emitter } from 'vs/base/common/event';\nimport URI from 'vs/base/common/uri';\n\nexport function isThenable<T>(obj: any): obj is Thenable<T> {\n\treturn obj && typeof (<Thenable<any>>obj).then === 'function';\n}\n\nexport function toThenable<T>(arg: T | Thenable<T>): Thenable<T> {\n\tif (isThenable(arg)) {\n\t\treturn arg;\n\t} else {\n\t\treturn TPromise.as(arg);\n\t}\n}\n\nexport function asWinJsPromise<T>(callback: (token: CancellationToken) => T | TPromise<T> | Thenable<T>): TPromise<T> {\n\tlet source = new CancellationTokenSource();\n\treturn new TPromise<T>((resolve, reject, progress) => {\n\t\tlet item = callback(source.token);\n\t\tif (item instanceof TPromise) {\n\t\t\titem.then(result => {\n\t\t\t\tsource.dispose();\n\t\t\t\tresolve(result);\n\t\t\t}, err => {\n\t\t\t\tsource.dispose();\n\t\t\t\treject(err);\n\t\t\t}, progress);\n\t\t} else if (isThenable<T>(item)) {\n\t\t\titem.then(result => {\n\t\t\t\tsource.dispose();\n\t\t\t\tresolve(result);\n\t\t\t}, err => {\n\t\t\t\tsource.dispose();\n\t\t\t\treject(err);\n\t\t\t});\n\t\t} else {\n\t\t\tsource.dispose();\n\t\t\tresolve(item);\n\t\t}\n\t}, () => {\n\t\tsource.cancel();\n\t});\n}\n\n/**\n * Hook a cancellation token to a WinJS Promise\n */\nexport function wireCancellationToken<T>(token: CancellationToken, promise: TPromise<T>, resolveAsUndefinedWhenCancelled?: boolean): Thenable<T> {\n\tconst subscription = token.onCancellationRequested(() => promise.cancel());\n\tif (resolveAsUndefinedWhenCancelled) {\n\t\tpromise = promise.then<T>(undefined, err => {\n\t\t\tif (!errors.isPromiseCanceledError(err)) {\n\t\t\t\treturn TPromise.wrapError(err);\n\t\t\t}\n\t\t\treturn undefined;\n\t\t});\n\t}\n\treturn always(promise, () => subscription.dispose());\n}\n\nexport interface ITask<T> {\n\t(): T;\n}\n\n/**\n * A helper to prevent accumulation of sequential async tasks.\n *\n * Imagine a mail man with the sole task of delivering letters. As soon as\n * a letter submitted for delivery, he drives to the destination, delivers it\n * and returns to his base. Imagine that during the trip, N more letters were submitted.\n * When the mail man returns, he picks those N letters and delivers them all in a\n * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.\n *\n * The throttler implements this via the queue() method, by providing it a task\n * factory. Following the example:\n *\n * \t\tconst throttler = new Throttler();\n * \t\tconst letters = [];\n *\n * \t\tfunction deliver() {\n * \t\t\tconst lettersToDeliver = letters;\n * \t\t\tletters = [];\n * \t\t\treturn makeTheTrip(lettersToDeliver);\n * \t\t}\n *\n * \t\tfunction onLetterReceived(l) {\n * \t\t\tletters.push(l);\n * \t\t\tthrottler.queue(deliver);\n * \t\t}\n */\nexport class Throttler {\n\n\tprivate activePromise: Promise;\n\tprivate queuedPromise: Promise;\n\tprivate queuedPromiseFactory: ITask<Promise>;\n\n\tconstructor() {\n\t\tthis.activePromise = null;\n\t\tthis.queuedPromise = null;\n\t\tthis.queuedPromiseFactory = null;\n\t}\n\n\tqueue<T>(promiseFactory: ITask<TPromise<T>>): TPromise<T> {\n\t\tif (this.activePromise) {\n\t\t\tthis.queuedPromiseFactory = promiseFactory;\n\n\t\t\tif (!this.queuedPromise) {\n\t\t\t\tconst onComplete = () => {\n\t\t\t\t\tthis.queuedPromise = null;\n\n\t\t\t\t\tconst result = this.queue(this.queuedPromiseFactory);\n\t\t\t\t\tthis.queuedPromiseFactory = null;\n\n\t\t\t\t\treturn result;\n\t\t\t\t};\n\n\t\t\t\tthis.queuedPromise = new TPromise((c, e, p) => {\n\t\t\t\t\tthis.activePromise.then(onComplete, onComplete, p).done(c);\n\t\t\t\t}, () => {\n\t\t\t\t\tthis.activePromise.cancel();\n\t\t\t\t});\n\t\t\t}\n\n\t\t\treturn new TPromise((c, e, p) => {\n\t\t\t\tthis.queuedPromise.then(c, e, p);\n\t\t\t}, () => {\n\t\t\t\t// no-op\n\t\t\t});\n\t\t}\n\n\t\tthis.activePromise = promiseFactory();\n\n\t\treturn new TPromise((c, e, p) => {\n\t\t\tthis.activePromise.done((result: any) => {\n\t\t\t\tthis.activePromise = null;\n\t\t\t\tc(result);\n\t\t\t}, (err: any) => {\n\t\t\t\tthis.activePromise = null;\n\t\t\t\te(err);\n\t\t\t}, p);\n\t\t}, () => {\n\t\t\tthis.activePromise.cancel();\n\t\t});\n\t}\n}\n\n// TODO@Joao: can the previous throttler be replaced with this?\nexport class SimpleThrottler {\n\n\tprivate current = TPromise.wrap<any>(null);\n\n\tqueue<T>(promiseTask: ITask<TPromise<T>>): TPromise<T> {\n\t\treturn this.current = this.current.then(() => promiseTask());\n\t}\n}\n\n/**\n * A helper to delay execution of a task that is being requested often.\n *\n * Following the throttler, now imagine the mail man wants to optimize the number of\n * trips proactively. The trip itself can be long, so the he decides not to make the trip\n * as soon as a letter is submitted. Instead he waits a while, in case more\n * letters are submitted. After said waiting period, if no letters were submitted, he\n * decides to make the trip. Imagine that N more letters were submitted after the first\n * one, all within a short period of time between each other. Even though N+1\n * submissions occurred, only 1 delivery was made.\n *\n * The delayer offers this behavior via the trigger() method, into which both the task\n * to be executed and the waiting period (delay) must be passed in as arguments. Following\n * the example:\n *\n * \t\tconst delayer = new Delayer(WAITING_PERIOD);\n * \t\tconst letters = [];\n *\n * \t\tfunction letterReceived(l) {\n * \t\t\tletters.push(l);\n * \t\t\tdelayer.trigger(() => { return makeTheTrip(); });\n * \t\t}\n */\nexport class Delayer<T> {\n\n\tprivate timeout: number;\n\tprivate completionPromise: Promise;\n\tprivate onSuccess: ValueCallback;\n\tprivate task: ITask<T | TPromise<T>>;\n\n\tconstructor(public defaultDelay: number) {\n\t\tthis.timeout = null;\n\t\tthis.completionPromise = null;\n\t\tthis.onSuccess = null;\n\t\tthis.task = null;\n\t}\n\n\ttrigger(task: ITask<T | TPromise<T>>, delay: number = this.defaultDelay): TPromise<T> {\n\t\tthis.task = task;\n\t\tthis.cancelTimeout();\n\n\t\tif (!this.completionPromise) {\n\t\t\tthis.completionPromise = new TPromise((c) => {\n\t\t\t\tthis.onSuccess = c;\n\t\t\t}, () => {\n\t\t\t\t// no-op\n\t\t\t}).then(() => {\n\t\t\t\tthis.completionPromise = null;\n\t\t\t\tthis.onSuccess = null;\n\t\t\t\tconst task = this.task;\n\t\t\t\tthis.task = null;\n\n\t\t\t\treturn task();\n\t\t\t});\n\t\t}\n\n\t\tthis.timeout = setTimeout(() => {\n\t\t\tthis.timeout = null;\n\t\t\tthis.onSuccess(null);\n\t\t}, delay);\n\n\t\treturn this.completionPromise;\n\t}\n\n\tisTriggered(): boolean {\n\t\treturn this.timeout !== null;\n\t}\n\n\tcancel(): void {\n\t\tthis.cancelTimeout();\n\n\t\tif (this.completionPromise) {\n\t\t\tthis.completionPromise.cancel();\n\t\t\tthis.completionPromise = null;\n\t\t}\n\t}\n\n\tprivate cancelTimeout(): void {\n\t\tif (this.timeout !== null) {\n\t\t\tclearTimeout(this.timeout);\n\t\t\tthis.timeout = null;\n\t\t}\n\t}\n}\n\n/**\n * A helper to delay execution of a task that is being requested often, while\n * preventing accumulation of consecutive executions, while the task runs.\n *\n * Simply combine the two mail man strategies from the Throttler and Delayer\n * helpers, for an analogy.\n */\nexport class ThrottledDelayer<T> extends Delayer<TPromise<T>> {\n\n\tprivate throttler: Throttler;\n\n\tconstructor(defaultDelay: number) {\n\t\tsuper(defaultDelay);\n\n\t\tthis.throttler = new Throttler();\n\t}\n\n\ttrigger(promiseFactory: ITask<TPromise<T>>, delay?: number): TPromise {\n\t\treturn super.trigger(() => this.throttler.queue(promiseFactory), delay);\n\t}\n}\n\n/**\n * A barrier that is initially closed and then becomes opened permanently.\n */\nexport class Barrier {\n\n\tprivate _isOpen: boolean;\n\tprivate _promise: TPromise<boolean>;\n\tprivate _completePromise: (v: boolean) => void;\n\n\tconstructor() {\n\t\tthis._isOpen = false;\n\t\tthis._promise = new TPromise<boolean>((c, e, p) => {\n\t\t\tthis._completePromise = c;\n\t\t}, () => {\n\t\t\tconsole.warn('You should really not try to cancel this ready promise!');\n\t\t});\n\t}\n\n\tisOpen(): boolean {\n\t\treturn this._isOpen;\n\t}\n\n\topen(): void {\n\t\tthis._isOpen = true;\n\t\tthis._completePromise(true);\n\t}\n\n\twait(): TPromise<boolean> {\n\t\treturn this._promise;\n\t}\n}\n\nexport class ShallowCancelThenPromise<T> extends TPromise<T> {\n\n\tconstructor(outer: TPromise<T>) {\n\n\t\tlet completeCallback: ValueCallback,\n\t\t\terrorCallback: ErrorCallback,\n\t\t\tprogressCallback: ProgressCallback;\n\n\t\tsuper((c, e, p) => {\n\t\t\tcompleteCallback = c;\n\t\t\terrorCallback = e;\n\t\t\tprogressCallback = p;\n\t\t}, () => {\n\t\t\t// cancel this promise but not the\n\t\t\t// outer promise\n\t\t\terrorCallback(errors.canceled());\n\t\t});\n\n\t\touter.then(completeCallback, errorCallback, progressCallback);\n\t}\n}\n\n/**\n * Replacement for `WinJS.Promise.timeout`.\n */\nexport function timeout(n: number): Promise<void> {\n\treturn new Promise(resolve => setTimeout(resolve, n));\n}\n\nfunction isWinJSPromise(candidate: any): candidate is TPromise {\n\treturn TPromise.is(candidate) && typeof (<TPromise>candidate).done === 'function';\n}\n\n/**\n * Returns a new promise that joins the provided promise. Upon completion of\n * the provided promise the provided function will always be called. This\n * method is comparable to a try-finally code block.\n * @param promise a promise\n * @param f a function that will be call in the success and error case.\n */\nexport function always<T>(thenable: TPromise<T>, f: Function): TPromise<T>;\nexport function always<T>(promise: Thenable<T>, f: Function): Thenable<T>;\nexport function always<T>(winjsPromiseOrThenable: Thenable<T> | TPromise<T>, f: Function): TPromise<T> | Thenable<T> {\n\tif (isWinJSPromise(winjsPromiseOrThenable)) {\n\t\treturn new TPromise<T>((c, e, p) => {\n\t\t\twinjsPromiseOrThenable.done((result) => {\n\t\t\t\ttry {\n\t\t\t\t\tf(result);\n\t\t\t\t} catch (e1) {\n\t\t\t\t\terrors.onUnexpectedError(e1);\n\t\t\t\t}\n\t\t\t\tc(result);\n\t\t\t}, (err) => {\n\t\t\t\ttry {\n\t\t\t\t\tf(err);\n\t\t\t\t} catch (e1) {\n\t\t\t\t\terrors.onUnexpectedError(e1);\n\t\t\t\t}\n\t\t\t\te(err);\n\t\t\t}, (progress) => {\n\t\t\t\tp(progress);\n\t\t\t});\n\t\t}, () => {\n\t\t\twinjsPromiseOrThenable.cancel();\n\t\t});\n\n\t} else {\n\t\t// simple\n\t\twinjsPromiseOrThenable.then(_ => f(), _ => f());\n\t\treturn winjsPromiseOrThenable;\n\t}\n}\n\n/**\n * Runs the provided list of promise factories in sequential order. The returned\n * promise will complete to an array of results from each promise.\n */\n\nexport function sequence<T>(promiseFactories: ITask<Thenable<T>>[]): TPromise<T[]> {\n\tconst results: T[] = [];\n\n\t// reverse since we start with last element using pop()\n\tpromiseFactories = promiseFactories.reverse();\n\n\tfunction next(): Thenable<any> {\n\t\tif (promiseFactories.length) {\n\t\t\treturn promiseFactories.pop()();\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tfunction thenHandler(result: any): Thenable<any> {\n\t\tif (result !== undefined && result !== null) {\n\t\t\tresults.push(result);\n\t\t}\n\n\t\tconst n = next();\n\t\tif (n) {\n\t\t\treturn n.then(thenHandler);\n\t\t}\n\n\t\treturn TPromise.as(results);\n\t}\n\n\treturn TPromise.as(null).then(thenHandler);\n}\n\nexport function first<T>(promiseFactories: ITask<TPromise<T>>[], shouldStop: (t: T) => boolean = t => !!t): TPromise<T> {\n\tpromiseFactories = [...promiseFactories.reverse()];\n\n\tconst loop: () => TPromise<T> = () => {\n\t\tif (promiseFactories.length === 0) {\n\t\t\treturn TPromise.as(null);\n\t\t}\n\n\t\tconst factory = promiseFactories.pop();\n\t\tconst promise = factory();\n\n\t\treturn promise.then(result => {\n\t\t\tif (shouldStop(result)) {\n\t\t\t\treturn TPromise.as(result);\n\t\t\t}\n\n\t\t\treturn loop();\n\t\t});\n\t};\n\n\treturn loop();\n}\n\ninterface ILimitedTaskFactory {\n\tfactory: ITask<Promise>;\n\tc: ValueCallback;\n\te: ErrorCallback;\n\tp: ProgressCallback;\n}\n\n/**\n * A helper to queue N promises and run them all with a max degree of parallelism. The helper\n * ensures that at any time no more than M promises are running at the same time.\n */\nexport class Limiter<T> {\n\tprivate runningPromises: number;\n\tprivate maxDegreeOfParalellism: number;\n\tprivate outstandingPromises: ILimitedTaskFactory[];\n\tprivate readonly _onFinished: Emitter<void>;\n\n\tconstructor(maxDegreeOfParalellism: number) {\n\t\tthis.maxDegreeOfParalellism = maxDegreeOfParalellism;\n\t\tthis.outstandingPromises = [];\n\t\tthis.runningPromises = 0;\n\t\tthis._onFinished = new Emitter<void>();\n\t}\n\n\tpublic get onFinished(): Event<void> {\n\t\treturn this._onFinished.event;\n\t}\n\n\tpublic get size(): number {\n\t\treturn this.runningPromises + this.outstandingPromises.length;\n\t}\n\n\tqueue(promiseFactory: ITask<Promise>): Promise;\n\tqueue(promiseFactory: ITask<TPromise<T>>): TPromise<T> {\n\t\treturn new TPromise<T>((c, e, p) => {\n\t\t\tthis.outstandingPromises.push({\n\t\t\t\tfactory: promiseFactory,\n\t\t\t\tc: c,\n\t\t\t\te: e,\n\t\t\t\tp: p\n\t\t\t});\n\n\t\t\tthis.consume();\n\t\t});\n\t}\n\n\tprivate consume(): void {\n\t\twhile (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {\n\t\t\tconst iLimitedTask = this.outstandingPromises.shift();\n\t\t\tthis.runningPromises++;\n\n\t\t\tconst promise = iLimitedTask.factory();\n\t\t\tpromise.done(iLimitedTask.c, iLimitedTask.e, iLimitedTask.p);\n\t\t\tpromise.done(() => this.consumed(), () => this.consumed());\n\t\t}\n\t}\n\n\tprivate consumed(): void {\n\t\tthis.runningPromises--;\n\n\t\tif (this.outstandingPromises.length > 0) {\n\t\t\tthis.consume();\n\t\t} else {\n\t\t\tthis._onFinished.fire();\n\t\t}\n\t}\n\n\tpublic dispose(): void {\n\t\tthis._onFinished.dispose();\n\t}\n}\n\n/**\n * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.\n */\nexport class Queue<T> extends Limiter<T> {\n\n\tconstructor() {\n\t\tsuper(1);\n\t}\n}\n\n/**\n * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource\n * by disposing them once the queue is empty.\n */\nexport class ResourceQueue {\n\tprivate queues: { [path: string]: Queue<void> };\n\n\tconstructor() {\n\t\tthis.queues = Object.create(null);\n\t}\n\n\tpublic queueFor(resource: URI): Queue<void> {\n\t\tconst key = resource.toString();\n\t\tif (!this.queues[key]) {\n\t\t\tconst queue = new Queue<void>();\n\t\t\tqueue.onFinished(() => {\n\t\t\t\tqueue.dispose();\n\t\t\t\tdelete this.queues[key];\n\t\t\t});\n\n\t\t\tthis.queues[key] = queue;\n\t\t}\n\n\t\treturn this.queues[key];\n\t}\n}\n\nexport function setDisposableTimeout(handler: Function, timeout: number, ...args: any[]): IDisposable {\n\tconst handle = setTimeout(handler, timeout, ...args);\n\treturn { dispose() { clearTimeout(handle); } };\n}\n\nexport class TimeoutTimer extends Disposable {\n\tprivate _token: number;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis._token = -1;\n\t}\n\n\tdispose(): void {\n\t\tthis.cancel();\n\t\tsuper.dispose();\n\t}\n\n\tcancel(): void {\n\t\tif (this._token !== -1) {\n\t\t\tclearTimeout(this._token);\n\t\t\tthis._token = -1;\n\t\t}\n\t}\n\n\tcancelAndSet(runner: () => void, timeout: number): void {\n\t\tthis.cancel();\n\t\tthis._token = setTimeout(() => {\n\t\t\tthis._token = -1;\n\t\t\trunner();\n\t\t}, timeout);\n\t}\n\n\tsetIfNotSet(runner: () => void, timeout: number): void {\n\t\tif (this._token !== -1) {\n\t\t\t// timer is already set\n\t\t\treturn;\n\t\t}\n\t\tthis._token = setTimeout(() => {\n\t\t\tthis._token = -1;\n\t\t\trunner();\n\t\t}, timeout);\n\t}\n}\n\nexport class IntervalTimer extends Disposable {\n\n\tprivate _token: number;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis._token = -1;\n\t}\n\n\tdispose(): void {\n\t\tthis.cancel();\n\t\tsuper.dispose();\n\t}\n\n\tcancel(): void {\n\t\tif (this._token !== -1) {\n\t\t\tclearInterval(this._token);\n\t\t\tthis._token = -1;\n\t\t}\n\t}\n\n\tcancelAndSet(runner: () => void, interval: number): void {\n\t\tthis.cancel();\n\t\tthis._token = setInterval(() => {\n\t\t\trunner();\n\t\t}, interval);\n\t}\n}\n\nexport class RunOnceScheduler {\n\n\tprivate timeoutToken: number;\n\tprivate runner: () => void;\n\tprivate timeout: number;\n\tprivate timeoutHandler: () => void;\n\n\tconstructor(runner: () => void, timeout: number) {\n\t\tthis.timeoutToken = -1;\n\t\tthis.runner = runner;\n\t\tthis.timeout = timeout;\n\t\tthis.timeoutHandler = this.onTimeout.bind(this);\n\t}\n\n\t/**\n\t * Dispose RunOnceScheduler\n\t */\n\tdispose(): void {\n\t\tthis.cancel();\n\t\tthis.runner = null;\n\t}\n\n\t/**\n\t * Cancel current scheduled runner (if any).\n\t */\n\tcancel(): void {\n\t\tif (this.isScheduled()) {\n\t\t\tclearTimeout(this.timeoutToken);\n\t\t\tthis.timeoutToken = -1;\n\t\t}\n\t}\n\n\t/**\n\t * Cancel previous runner (if any) & schedule a new runner.\n\t */\n\tschedule(delay = this.timeout): void {\n\t\tthis.cancel();\n\t\tthis.timeoutToken = setTimeout(this.timeoutHandler, delay);\n\t}\n\n\t/**\n\t * Returns true if scheduled.\n\t */\n\tisScheduled(): boolean {\n\t\treturn this.timeoutToken !== -1;\n\t}\n\n\tprivate onTimeout() {\n\t\tthis.timeoutToken = -1;\n\t\tif (this.runner) {\n\t\t\tthis.runner();\n\t\t}\n\t}\n}\n\nexport function nfcall(fn: Function, ...args: any[]): Promise;\nexport function nfcall<T>(fn: Function, ...args: any[]): TPromise<T>;\nexport function nfcall(fn: Function, ...args: any[]): any {\n\treturn new TPromise((c, e) => fn(...args, (err: any, result: any) => err ? e(err) : c(result)), () => null);\n}\n\nexport function ninvoke(thisArg: any, fn: Function, ...args: any[]): Promise;\nexport function ninvoke<T>(thisArg: any, fn: Function, ...args: any[]): TPromise<T>;\nexport function ninvoke(thisArg: any, fn: Function, ...args: any[]): any {\n\treturn new TPromise((c, e) => fn.call(thisArg, ...args, (err: any, result: any) => err ? e(err) : c(result)), () => null);\n}\n\n/**\n * An emitter that will ignore any events that occur during a specific code\n * execution triggered via throttle() until the promise has finished (either\n * successfully or with an error). Only after the promise has finished, the\n * last event that was fired during the operation will get emitted.\n *\n */\nexport class ThrottledEmitter<T> extends Emitter<T> {\n\tprivate suspended: boolean;\n\n\tprivate lastEvent: T;\n\tprivate hasLastEvent: boolean;\n\n\tpublic throttle<C>(promise: TPromise<C>): TPromise<C> {\n\t\tthis.suspended = true;\n\n\t\treturn always(promise, () => this.resume());\n\t}\n\n\tpublic fire(event?: T): any {\n\t\tif (this.suspended) {\n\t\t\tthis.lastEvent = event;\n\t\t\tthis.hasLastEvent = true;\n\n\t\t\treturn;\n\t\t}\n\n\t\treturn super.fire(event);\n\t}\n\n\tprivate resume(): void {\n\t\tthis.suspended = false;\n\n\t\tif (this.hasLastEvent) {\n\t\t\tthis.fire(this.lastEvent);\n\t\t}\n\n\t\tthis.hasLastEvent = false;\n\t\tthis.lastEvent = void 0;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { transformErrorForSerialization } from 'vs/base/common/errors';\nimport { Disposable } from 'vs/base/common/lifecycle';\nimport { ErrorCallback, TPromise, ValueCallback } from 'vs/base/common/winjs.base';\nimport { ShallowCancelThenPromise } from 'vs/base/common/async';\nimport { isWeb } from 'vs/base/common/platform';\n\nconst INITIALIZE = '$initialize';\n\nexport interface IWorker {\n\tgetId(): number;\n\tpostMessage(message: string): void;\n\tdispose(): void;\n}\n\nexport interface IWorkerCallback {\n\t(message: string): void;\n}\n\nexport interface IWorkerFactory {\n\tcreate(moduleId: string, callback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker;\n}\n\nlet webWorkerWarningLogged = false;\nexport function logOnceWebWorkerWarning(err: any): void {\n\tif (!isWeb) {\n\t\t// running tests\n\t\treturn;\n\t}\n\tif (!webWorkerWarningLogged) {\n\t\twebWorkerWarningLogged = true;\n\t\tconsole.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\t}\n\tconsole.warn(err.message);\n}\n\ninterface IMessage {\n\tvsWorker: number;\n\treq?: string;\n\tseq?: string;\n}\n\ninterface IRequestMessage extends IMessage {\n\treq: string;\n\tmethod: string;\n\targs: any[];\n}\n\ninterface IReplyMessage extends IMessage {\n\tseq: string;\n\terr: any;\n\tres: any;\n}\n\ninterface IMessageReply {\n\tc: ValueCallback;\n\te: ErrorCallback;\n}\n\ninterface IMessageHandler {\n\tsendMessage(msg: string): void;\n\thandleMessage(method: string, args: any[]): TPromise<any>;\n}\n\nclass SimpleWorkerProtocol {\n\n\tprivate _workerId: number;\n\tprivate _lastSentReq: number;\n\tprivate _pendingReplies: { [req: string]: IMessageReply; };\n\tprivate _handler: IMessageHandler;\n\n\tconstructor(handler: IMessageHandler) {\n\t\tthis._workerId = -1;\n\t\tthis._handler = handler;\n\t\tthis._lastSentReq = 0;\n\t\tthis._pendingReplies = Object.create(null);\n\t}\n\n\tpublic setWorkerId(workerId: number): void {\n\t\tthis._workerId = workerId;\n\t}\n\n\tpublic sendMessage(method: string, args: any[]): TPromise<any> {\n\t\tlet req = String(++this._lastSentReq);\n\t\tlet reply: IMessageReply = {\n\t\t\tc: null,\n\t\t\te: null\n\t\t};\n\t\tlet result = new TPromise<any>((c, e, p) => {\n\t\t\treply.c = c;\n\t\t\treply.e = e;\n\t\t}, () => {\n\t\t\t// Cancel not supported\n\t\t});\n\t\tthis._pendingReplies[req] = reply;\n\n\t\tthis._send({\n\t\t\tvsWorker: this._workerId,\n\t\t\treq: req,\n\t\t\tmethod: method,\n\t\t\targs: args\n\t\t});\n\n\t\treturn result;\n\t}\n\n\tpublic handleMessage(serializedMessage: string): void {\n\t\tlet message: IMessage;\n\t\ttry {\n\t\t\tmessage = JSON.parse(serializedMessage);\n\t\t} catch (e) {\n\t\t\t// nothing\n\t\t}\n\t\tif (!message || !message.vsWorker) {\n\t\t\treturn;\n\t\t}\n\t\tif (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n\t\t\treturn;\n\t\t}\n\t\tthis._handleMessage(message);\n\t}\n\n\tprivate _handleMessage(msg: IMessage): void {\n\t\tif (msg.seq) {\n\t\t\tlet replyMessage = <IReplyMessage>msg;\n\t\t\tif (!this._pendingReplies[replyMessage.seq]) {\n\t\t\t\tconsole.warn('Got reply to unknown seq');\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tlet reply = this._pendingReplies[replyMessage.seq];\n\t\t\tdelete this._pendingReplies[replyMessage.seq];\n\n\t\t\tif (replyMessage.err) {\n\t\t\t\tlet err = replyMessage.err;\n\t\t\t\tif (replyMessage.err.$isError) {\n\t\t\t\t\terr = new Error();\n\t\t\t\t\terr.name = replyMessage.err.name;\n\t\t\t\t\terr.message = replyMessage.err.message;\n\t\t\t\t\terr.stack = replyMessage.err.stack;\n\t\t\t\t}\n\t\t\t\treply.e(err);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\treply.c(replyMessage.res);\n\t\t\treturn;\n\t\t}\n\n\t\tlet requestMessage = <IRequestMessage>msg;\n\t\tlet req = requestMessage.req;\n\t\tlet result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n\t\tresult.then((r) => {\n\t\t\tthis._send({\n\t\t\t\tvsWorker: this._workerId,\n\t\t\t\tseq: req,\n\t\t\t\tres: r,\n\t\t\t\terr: undefined\n\t\t\t});\n\t\t}, (e) => {\n\t\t\tif (e.detail instanceof Error) {\n\t\t\t\t// Loading errors have a detail property that points to the actual error\n\t\t\t\te.detail = transformErrorForSerialization(e.detail);\n\t\t\t}\n\t\t\tthis._send({\n\t\t\t\tvsWorker: this._workerId,\n\t\t\t\tseq: req,\n\t\t\t\tres: undefined,\n\t\t\t\terr: transformErrorForSerialization(e)\n\t\t\t});\n\t\t});\n\t}\n\n\tprivate _send(msg: IRequestMessage | IReplyMessage): void {\n\t\tlet strMsg = JSON.stringify(msg);\n\t\t// console.log('SENDING: ' + strMsg);\n\t\tthis._handler.sendMessage(strMsg);\n\t}\n}\n\n/**\n * Main thread side\n */\nexport class SimpleWorkerClient<T> extends Disposable {\n\n\tprivate _worker: IWorker;\n\tprivate _onModuleLoaded: TPromise<string[]>;\n\tprivate _protocol: SimpleWorkerProtocol;\n\tprivate _lazyProxy: TPromise<T>;\n\n\tconstructor(workerFactory: IWorkerFactory, moduleId: string) {\n\t\tsuper();\n\n\t\tlet lazyProxyFulfill: (v: T) => void = null;\n\t\tlet lazyProxyReject: (err: any) => void = null;\n\n\t\tthis._worker = this._register(workerFactory.create(\n\t\t\t'vs/base/common/worker/simpleWorker',\n\t\t\t(msg: string) => {\n\t\t\t\tthis._protocol.handleMessage(msg);\n\t\t\t},\n\t\t\t(err: any) => {\n\t\t\t\t// in Firefox, web workers fail lazily :(\n\t\t\t\t// we will reject the proxy\n\t\t\t\tlazyProxyReject(err);\n\t\t\t}\n\t\t));\n\n\t\tthis._protocol = new SimpleWorkerProtocol({\n\t\t\tsendMessage: (msg: string): void => {\n\t\t\t\tthis._worker.postMessage(msg);\n\t\t\t},\n\t\t\thandleMessage: (method: string, args: any[]): TPromise<any> => {\n\t\t\t\t// Intentionally not supporting worker -> main requests\n\t\t\t\treturn TPromise.as(null);\n\t\t\t}\n\t\t});\n\t\tthis._protocol.setWorkerId(this._worker.getId());\n\n\t\t// Gather loader configuration\n\t\tlet loaderConfiguration: any = null;\n\t\tif (typeof (<any>self).require !== 'undefined' && typeof (<any>self).require.getConfig === 'function') {\n\t\t\t// Get the configuration from the Monaco AMD Loader\n\t\t\tloaderConfiguration = (<any>self).require.getConfig();\n\t\t} else if (typeof (<any>self).requirejs !== 'undefined') {\n\t\t\t// Get the configuration from requirejs\n\t\t\tloaderConfiguration = (<any>self).requirejs.s.contexts._.config;\n\t\t}\n\n\t\tthis._lazyProxy = new TPromise<T>((c, e, p) => {\n\t\t\tlazyProxyFulfill = c;\n\t\t\tlazyProxyReject = e;\n\t\t}, () => { /* no cancel */ });\n\n\t\t// Send initialize message\n\t\tthis._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [\n\t\t\tthis._worker.getId(),\n\t\t\tmoduleId,\n\t\t\tloaderConfiguration\n\t\t]);\n\t\tthis._onModuleLoaded.then((availableMethods: string[]) => {\n\t\t\tlet proxy = <T>{};\n\t\t\tfor (let i = 0; i < availableMethods.length; i++) {\n\t\t\t\t(proxy as any)[availableMethods[i]] = createProxyMethod(availableMethods[i], proxyMethodRequest);\n\t\t\t}\n\t\t\tlazyProxyFulfill(proxy);\n\t\t}, (e) => {\n\t\t\tlazyProxyReject(e);\n\t\t\tthis._onError('Worker failed to load ' + moduleId, e);\n\t\t});\n\n\t\t// Create proxy to loaded code\n\t\tlet proxyMethodRequest = (method: string, args: any[]): TPromise<any> => {\n\t\t\treturn this._request(method, args);\n\t\t};\n\n\t\tlet createProxyMethod = (method: string, proxyMethodRequest: (method: string, args: any[]) => TPromise<any>): Function => {\n\t\t\treturn function () {\n\t\t\t\tlet args = Array.prototype.slice.call(arguments, 0);\n\t\t\t\treturn proxyMethodRequest(method, args);\n\t\t\t};\n\t\t};\n\t}\n\n\tpublic getProxyObject(): TPromise<T> {\n\t\t// Do not allow chaining promises to cancel the proxy creation\n\t\treturn new ShallowCancelThenPromise(this._lazyProxy);\n\t}\n\n\tprivate _request(method: string, args: any[]): TPromise<any> {\n\t\treturn new TPromise<any>((c, e, p) => {\n\t\t\tthis._onModuleLoaded.then(() => {\n\t\t\t\tthis._protocol.sendMessage(method, args).then(c, e);\n\t\t\t}, e);\n\t\t}, () => {\n\t\t\t// Cancel intentionally not supported\n\t\t});\n\t}\n\n\tprivate _onError(message: string, error?: any): void {\n\t\tconsole.error(message);\n\t\tconsole.info(error);\n\t}\n}\n\nexport interface IRequestHandler {\n\t_requestHandlerBrand: any;\n}\n\n/**\n * Worker side\n */\nexport class SimpleWorkerServer {\n\n\tprivate _requestHandler: IRequestHandler;\n\tprivate _protocol: SimpleWorkerProtocol;\n\n\tconstructor(postSerializedMessage: (msg: string) => void, requestHandler: IRequestHandler) {\n\t\tthis._requestHandler = requestHandler;\n\t\tthis._protocol = new SimpleWorkerProtocol({\n\t\t\tsendMessage: (msg: string): void => {\n\t\t\t\tpostSerializedMessage(msg);\n\t\t\t},\n\t\t\thandleMessage: (method: string, args: any[]): TPromise<any> => this._handleMessage(method, args)\n\t\t});\n\t}\n\n\tpublic onmessage(msg: string): void {\n\t\tthis._protocol.handleMessage(msg);\n\t}\n\n\tprivate _handleMessage(method: string, args: any[]): TPromise<any> {\n\t\tif (method === INITIALIZE) {\n\t\t\treturn this.initialize(<number>args[0], <string>args[1], <any>args[2]);\n\t\t}\n\n\t\tif (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n\t\t\treturn TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));\n\t\t}\n\n\t\ttry {\n\t\t\treturn TPromise.as(this._requestHandler[method].apply(this._requestHandler, args));\n\t\t} catch (e) {\n\t\t\treturn TPromise.wrapError(e);\n\t\t}\n\t}\n\n\tprivate initialize(workerId: number, moduleId: string, loaderConfig: any): TPromise<any> {\n\t\tthis._protocol.setWorkerId(workerId);\n\n\t\tif (this._requestHandler) {\n\t\t\t// static request handler\n\t\t\tlet methods: string[] = [];\n\t\t\tfor (let prop in this._requestHandler) {\n\t\t\t\tif (typeof this._requestHandler[prop] === 'function') {\n\t\t\t\t\tmethods.push(prop);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn TPromise.as(methods);\n\t\t}\n\n\t\tif (loaderConfig) {\n\t\t\t// Remove 'baseUrl', handling it is beyond scope for now\n\t\t\tif (typeof loaderConfig.baseUrl !== 'undefined') {\n\t\t\t\tdelete loaderConfig['baseUrl'];\n\t\t\t}\n\t\t\tif (typeof loaderConfig.paths !== 'undefined') {\n\t\t\t\tif (typeof loaderConfig.paths.vs !== 'undefined') {\n\t\t\t\t\tdelete loaderConfig.paths['vs'];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Since this is in a web worker, enable catching errors\n\t\t\tloaderConfig.catchError = true;\n\t\t\t(<any>self).require.config(loaderConfig);\n\t\t}\n\n\t\tlet cc: ValueCallback;\n\t\tlet ee: ErrorCallback;\n\t\tlet r = new TPromise<any>((c, e, p) => {\n\t\t\tcc = c;\n\t\t\tee = e;\n\t\t});\n\n\t\t// Use the global require to be sure to get the global config\n\t\t(<any>self).require([moduleId], (...result: any[]) => {\n\t\t\tlet handlerModule = result[0];\n\t\t\tthis._requestHandler = handlerModule.create();\n\n\t\t\tlet methods: string[] = [];\n\t\t\tfor (let prop in this._requestHandler) {\n\t\t\t\tif (typeof this._requestHandler[prop] === 'function') {\n\t\t\t\t\tmethods.push(prop);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcc(methods);\n\t\t}, ee);\n\n\t\treturn r;\n\t}\n}\n\n/**\n * Called on the worker side\n */\nexport function create(postMessage: (msg: string) => void): SimpleWorkerServer {\n\treturn 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'use strict';\n\n/**\n * A position in the editor. This interface is suitable for serialization.\n */\nexport interface IPosition {\n\t/**\n\t * line number (starts at 1)\n\t */\n\treadonly lineNumber: number;\n\t/**\n\t * column (the first character in a line is between column 1 and column 2)\n\t */\n\treadonly column: number;\n}\n\n/**\n * A position in the editor.\n */\nexport class Position {\n\t/**\n\t * line number (starts at 1)\n\t */\n\tpublic readonly lineNumber: number;\n\t/**\n\t * column (the first character in a line is between column 1 and column 2)\n\t */\n\tpublic readonly column: number;\n\n\tconstructor(lineNumber: number, column: number) {\n\t\tthis.lineNumber = lineNumber;\n\t\tthis.column = column;\n\t}\n\n\t/**\n\t * Test if this position equals other position\n\t */\n\tpublic equals(other: IPosition): boolean {\n\t\treturn Position.equals(this, other);\n\t}\n\n\t/**\n\t * Test if position `a` equals position `b`\n\t */\n\tpublic static equals(a: IPosition, b: IPosition): boolean {\n\t\tif (!a && !b) {\n\t\t\treturn true;\n\t\t}\n\t\treturn (\n\t\t\t!!a &&\n\t\t\t!!b &&\n\t\t\ta.lineNumber === b.lineNumber &&\n\t\t\ta.column === b.column\n\t\t);\n\t}\n\n\t/**\n\t * Test if this position is before other position.\n\t * If the two positions are equal, the result will be false.\n\t */\n\tpublic isBefore(other: IPosition): boolean {\n\t\treturn Position.isBefore(this, other);\n\t}\n\n\t/**\n\t * Test if position `a` is before position `b`.\n\t * If the two positions are equal, the result will be false.\n\t */\n\tpublic static isBefore(a: IPosition, b: IPosition): boolean {\n\t\tif (a.lineNumber < b.lineNumber) {\n\t\t\treturn true;\n\t\t}\n\t\tif (b.lineNumber < a.lineNumber) {\n\t\t\treturn false;\n\t\t}\n\t\treturn a.column < b.column;\n\t}\n\n\t/**\n\t * Test if this position is before other position.\n\t * If the two positions are equal, the result will be true.\n\t */\n\tpublic isBeforeOrEqual(other: IPosition): boolean {\n\t\treturn Position.isBeforeOrEqual(this, other);\n\t}\n\n\t/**\n\t * Test if position `a` is before position `b`.\n\t * If the two positions are equal, the result will be true.\n\t */\n\tpublic static isBeforeOrEqual(a: IPosition, b: IPosition): boolean {\n\t\tif (a.lineNumber < b.lineNumber) {\n\t\t\treturn true;\n\t\t}\n\t\tif (b.lineNumber < a.lineNumber) {\n\t\t\treturn false;\n\t\t}\n\t\treturn a.column <= b.column;\n\t}\n\n\t/**\n\t * A function that compares positions, useful for sorting\n\t */\n\tpublic static compare(a: IPosition, b: IPosition): number {\n\t\tlet aLineNumber = a.lineNumber | 0;\n\t\tlet bLineNumber = b.lineNumber | 0;\n\n\t\tif (aLineNumber === bLineNumber) {\n\t\t\tlet aColumn = a.column | 0;\n\t\t\tlet bColumn = b.column | 0;\n\t\t\treturn aColumn - bColumn;\n\t\t}\n\n\t\treturn aLineNumber - bLineNumber;\n\t}\n\n\t/**\n\t * Clone this position.\n\t */\n\tpublic clone(): Position {\n\t\treturn new Position(this.lineNumber, this.column);\n\t}\n\n\t/**\n\t * Convert to a human-readable representation.\n\t */\n\tpublic toString(): string {\n\t\treturn '(' + this.lineNumber + ',' + this.column + ')';\n\t}\n\n\t// ---\n\n\t/**\n\t * Create a `Position` from an `IPosition`.\n\t */\n\tpublic static lift(pos: IPosition): Position {\n\t\treturn new Position(pos.lineNumber, pos.column);\n\t}\n\n\t/**\n\t * Test if `obj` is an `IPosition`.\n\t */\n\tpublic static isIPosition(obj: any): obj is IPosition {\n\t\treturn (\n\t\t\tobj\n\t\t\t&& (typeof obj.lineNumber === 'number')\n\t\t\t&& (typeof obj.column === 'number')\n\t\t);\n\t}\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'use strict';\n\nimport { Position, IPosition } from 'vs/editor/common/core/position';\n\n/**\n * A range in the editor. This interface is suitable for serialization.\n */\nexport interface IRange {\n\t/**\n\t * Line number on which the range starts (starts at 1).\n\t */\n\treadonly startLineNumber: number;\n\t/**\n\t * Column on which the range starts in line `startLineNumber` (starts at 1).\n\t */\n\treadonly startColumn: number;\n\t/**\n\t * Line number on which the range ends.\n\t */\n\treadonly endLineNumber: number;\n\t/**\n\t * Column on which the range ends in line `endLineNumber`.\n\t */\n\treadonly endColumn: number;\n}\n\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nexport class Range {\n\n\t/**\n\t * Line number on which the range starts (starts at 1).\n\t */\n\tpublic readonly startLineNumber: number;\n\t/**\n\t * Column on which the range starts in line `startLineNumber` (starts at 1).\n\t */\n\tpublic readonly startColumn: number;\n\t/**\n\t * Line number on which the range ends.\n\t */\n\tpublic readonly endLineNumber: number;\n\t/**\n\t * Column on which the range ends in line `endLineNumber`.\n\t */\n\tpublic readonly endColumn: number;\n\n\tconstructor(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number) {\n\t\tif ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n\t\t\tthis.startLineNumber = endLineNumber;\n\t\t\tthis.startColumn = endColumn;\n\t\t\tthis.endLineNumber = startLineNumber;\n\t\t\tthis.endColumn = startColumn;\n\t\t} else {\n\t\t\tthis.startLineNumber = startLineNumber;\n\t\t\tthis.startColumn = startColumn;\n\t\t\tthis.endLineNumber = endLineNumber;\n\t\t\tthis.endColumn = endColumn;\n\t\t}\n\t}\n\n\t/**\n\t * Test if this range is empty.\n\t */\n\tpublic isEmpty(): boolean {\n\t\treturn Range.isEmpty(this);\n\t}\n\n\t/**\n\t * Test if `range` is empty.\n\t */\n\tpublic static isEmpty(range: IRange): boolean {\n\t\treturn (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n\t}\n\n\t/**\n\t * Test if position is in this range. If the position is at the edges, will return true.\n\t */\n\tpublic containsPosition(position: IPosition): boolean {\n\t\treturn Range.containsPosition(this, position);\n\t}\n\n\t/**\n\t * Test if `position` is in `range`. If the position is at the edges, will return true.\n\t */\n\tpublic static containsPosition(range: IRange, position: IPosition): boolean {\n\t\tif (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n\t\t\treturn false;\n\t\t}\n\t\tif (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n\t\t\treturn false;\n\t\t}\n\t\tif (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * Test if range is in this range. If the range is equal to this range, will return true.\n\t */\n\tpublic containsRange(range: IRange): boolean {\n\t\treturn Range.containsRange(this, range);\n\t}\n\n\t/**\n\t * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n\t */\n\tpublic static containsRange(range: IRange, otherRange: IRange): boolean {\n\t\tif (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n\t\t\treturn false;\n\t\t}\n\t\tif (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n\t\t\treturn false;\n\t\t}\n\t\tif (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n\t\t\treturn false;\n\t\t}\n\t\tif (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * A reunion of the two ranges.\n\t * The smallest position will be used as the start point, and the largest one as the end point.\n\t */\n\tpublic plusRange(range: IRange): Range {\n\t\treturn Range.plusRange(this, range);\n\t}\n\n\t/**\n\t * A reunion of the two ranges.\n\t * The smallest position will be used as the start point, and the largest one as the end point.\n\t */\n\tpublic static plusRange(a: IRange, b: IRange): Range {\n\t\tlet startLineNumber: number;\n\t\tlet startColumn: number;\n\t\tlet endLineNumber: number;\n\t\tlet endColumn: number;\n\n\t\tif (b.startLineNumber < a.startLineNumber) {\n\t\t\tstartLineNumber = b.startLineNumber;\n\t\t\tstartColumn = b.startColumn;\n\t\t} else if (b.startLineNumber === a.startLineNumber) {\n\t\t\tstartLineNumber = b.startLineNumber;\n\t\t\tstartColumn = Math.min(b.startColumn, a.startColumn);\n\t\t} else {\n\t\t\tstartLineNumber = a.startLineNumber;\n\t\t\tstartColumn = a.startColumn;\n\t\t}\n\n\t\tif (b.endLineNumber > a.endLineNumber) {\n\t\t\tendLineNumber = b.endLineNumber;\n\t\t\tendColumn = b.endColumn;\n\t\t} else if (b.endLineNumber === a.endLineNumber) {\n\t\t\tendLineNumber = b.endLineNumber;\n\t\t\tendColumn = Math.max(b.endColumn, a.endColumn);\n\t\t} else {\n\t\t\tendLineNumber = a.endLineNumber;\n\t\t\tendColumn = a.endColumn;\n\t\t}\n\n\t\treturn new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n\t}\n\n\t/**\n\t * A intersection of the two ranges.\n\t */\n\tpublic intersectRanges(range: IRange): Range {\n\t\treturn Range.intersectRanges(this, range);\n\t}\n\n\t/**\n\t * A intersection of the two ranges.\n\t */\n\tpublic static intersectRanges(a: IRange, b: IRange): Range {\n\t\tlet resultStartLineNumber = a.startLineNumber;\n\t\tlet resultStartColumn = a.startColumn;\n\t\tlet resultEndLineNumber = a.endLineNumber;\n\t\tlet resultEndColumn = a.endColumn;\n\t\tlet otherStartLineNumber = b.startLineNumber;\n\t\tlet otherStartColumn = b.startColumn;\n\t\tlet otherEndLineNumber = b.endLineNumber;\n\t\tlet otherEndColumn = b.endColumn;\n\n\t\tif (resultStartLineNumber < otherStartLineNumber) {\n\t\t\tresultStartLineNumber = otherStartLineNumber;\n\t\t\tresultStartColumn = otherStartColumn;\n\t\t} else if (resultStartLineNumber === otherStartLineNumber) {\n\t\t\tresultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n\t\t}\n\n\t\tif (resultEndLineNumber > otherEndLineNumber) {\n\t\t\tresultEndLineNumber = otherEndLineNumber;\n\t\t\tresultEndColumn = otherEndColumn;\n\t\t} else if (resultEndLineNumber === otherEndLineNumber) {\n\t\t\tresultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n\t\t}\n\n\t\t// Check if selection is now empty\n\t\tif (resultStartLineNumber > resultEndLineNumber) {\n\t\t\treturn null;\n\t\t}\n\t\tif (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n\t\t\treturn null;\n\t\t}\n\t\treturn new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n\t}\n\n\t/**\n\t * Test if this range equals other.\n\t */\n\tpublic equalsRange(other: IRange): boolean {\n\t\treturn Range.equalsRange(this, other);\n\t}\n\n\t/**\n\t * Test if range `a` equals `b`.\n\t */\n\tpublic static equalsRange(a: IRange, b: IRange): boolean {\n\t\treturn (\n\t\t\t!!a &&\n\t\t\t!!b &&\n\t\t\ta.startLineNumber === b.startLineNumber &&\n\t\t\ta.startColumn === b.startColumn &&\n\t\t\ta.endLineNumber === b.endLineNumber &&\n\t\t\ta.endColumn === b.endColumn\n\t\t);\n\t}\n\n\t/**\n\t * Return the end position (which will be after or equal to the start position)\n\t */\n\tpublic getEndPosition(): Position {\n\t\treturn new Position(this.endLineNumber, this.endColumn);\n\t}\n\n\t/**\n\t * Return the start position (which will be before or equal to the end position)\n\t */\n\tpublic getStartPosition(): Position {\n\t\treturn new Position(this.startLineNumber, this.startColumn);\n\t}\n\n\t/**\n\t * Transform to a user presentable string representation.\n\t */\n\tpublic toString(): string {\n\t\treturn '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n\t}\n\n\t/**\n\t * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n\t */\n\tpublic setEndPosition(endLineNumber: number, endColumn: number): Range {\n\t\treturn new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n\t}\n\n\t/**\n\t * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n\t */\n\tpublic setStartPosition(startLineNumber: number, startColumn: number): Range {\n\t\treturn new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n\t}\n\n\t/**\n\t * Create a new empty range using this range's start position.\n\t */\n\tpublic collapseToStart(): Range {\n\t\treturn Range.collapseToStart(this);\n\t}\n\n\t/**\n\t * Create a new empty range using this range's start position.\n\t */\n\tpublic static collapseToStart(range: IRange): Range {\n\t\treturn new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n\t}\n\n\t// ---\n\n\tpublic static fromPositions(start: IPosition, end: IPosition = start): Range {\n\t\treturn new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n\t}\n\n\t/**\n\t * Create a `Range` from an `IRange`.\n\t */\n\tpublic static lift(range: IRange): Range {\n\t\tif (!range) {\n\t\t\treturn null;\n\t\t}\n\t\treturn new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n\t}\n\n\t/**\n\t * Test if `obj` is an `IRange`.\n\t */\n\tpublic static isIRange(obj: any): obj is IRange {\n\t\treturn (\n\t\t\tobj\n\t\t\t&& (typeof obj.startLineNumber === 'number')\n\t\t\t&& (typeof obj.startColumn === 'number')\n\t\t\t&& (typeof obj.endLineNumber === 'number')\n\t\t\t&& (typeof obj.endColumn === 'number')\n\t\t);\n\t}\n\n\t/**\n\t * Test if the two ranges are touching in any way.\n\t */\n\tpublic static areIntersectingOrTouching(a: IRange, b: IRange): boolean {\n\t\t// Check if `a` is before `b`\n\t\tif (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Check if `b` is before `a`\n\t\tif (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// These ranges must intersect\n\t\treturn true;\n\t}\n\n\t/**\n\t * A function that compares ranges, useful for sorting ranges\n\t * It will first compare ranges on the startPosition and then on the endPosition\n\t */\n\tpublic static compareRangesUsingStarts(a: IRange, b: IRange): number {\n\t\tlet aStartLineNumber = a.startLineNumber | 0;\n\t\tlet bStartLineNumber = b.startLineNumber | 0;\n\n\t\tif (aStartLineNumber === bStartLineNumber) {\n\t\t\tlet aStartColumn = a.startColumn | 0;\n\t\t\tlet bStartColumn = b.startColumn | 0;\n\n\t\t\tif (aStartColumn === bStartColumn) {\n\t\t\t\tlet aEndLineNumber = a.endLineNumber | 0;\n\t\t\t\tlet bEndLineNumber = b.endLineNumber | 0;\n\n\t\t\t\tif (aEndLineNumber === bEndLineNumber) {\n\t\t\t\t\tlet aEndColumn = a.endColumn | 0;\n\t\t\t\t\tlet bEndColumn = b.endColumn | 0;\n\t\t\t\t\treturn aEndColumn - bEndColumn;\n\t\t\t\t}\n\t\t\t\treturn aEndLineNumber - bEndLineNumber;\n\t\t\t}\n\t\t\treturn aStartColumn - bStartColumn;\n\t\t}\n\t\treturn aStartLineNumber - bStartLineNumber;\n\t}\n\n\t/**\n\t * A function that compares ranges, useful for sorting ranges\n\t * It will first compare ranges on the endPosition and then on the startPosition\n\t */\n\tpublic static compareRangesUsingEnds(a: IRange, b: IRange): number {\n\t\tif (a.endLineNumber === b.endLineNumber) {\n\t\t\tif (a.endColumn === b.endColumn) {\n\t\t\t\tif (a.startLineNumber === b.startLineNumber) {\n\t\t\t\t\treturn a.startColumn - b.startColumn;\n\t\t\t\t}\n\t\t\t\treturn a.startLineNumber - b.startLineNumber;\n\t\t\t}\n\t\t\treturn a.endColumn - b.endColumn;\n\t\t}\n\t\treturn a.endLineNumber - b.endLineNumber;\n\t}\n\n\t/**\n\t * Test if the range spans multiple lines.\n\t */\n\tpublic static spansMultipleLines(range: IRange): boolean {\n\t\treturn range.endLineNumber > range.startLineNumber;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { Range } from 'vs/editor/common/core/range';\nimport { Position, IPosition } from 'vs/editor/common/core/position';\n\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport interface ISelection {\n\t/**\n\t * The line number on which the selection has started.\n\t */\n\treadonly selectionStartLineNumber: number;\n\t/**\n\t * The column on `selectionStartLineNumber` where the selection has started.\n\t */\n\treadonly selectionStartColumn: number;\n\t/**\n\t * The line number on which the selection has ended.\n\t */\n\treadonly positionLineNumber: number;\n\t/**\n\t * The column on `positionLineNumber` where the selection has ended.\n\t */\n\treadonly positionColumn: number;\n}\n\n/**\n * The direction of a selection.\n */\nexport enum SelectionDirection {\n\t/**\n\t * The selection starts above where it ends.\n\t */\n\tLTR,\n\t/**\n\t * The selection starts below where it ends.\n\t */\n\tRTL\n}\n\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport class Selection extends Range {\n\t/**\n\t * The line number on which the selection has started.\n\t */\n\tpublic readonly selectionStartLineNumber: number;\n\t/**\n\t * The column on `selectionStartLineNumber` where the selection has started.\n\t */\n\tpublic readonly selectionStartColumn: number;\n\t/**\n\t * The line number on which the selection has ended.\n\t */\n\tpublic readonly positionLineNumber: number;\n\t/**\n\t * The column on `positionLineNumber` where the selection has ended.\n\t */\n\tpublic readonly positionColumn: number;\n\n\tconstructor(selectionStartLineNumber: number, selectionStartColumn: number, positionLineNumber: number, positionColumn: number) {\n\t\tsuper(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);\n\t\tthis.selectionStartLineNumber = selectionStartLineNumber;\n\t\tthis.selectionStartColumn = selectionStartColumn;\n\t\tthis.positionLineNumber = positionLineNumber;\n\t\tthis.positionColumn = positionColumn;\n\t}\n\n\t/**\n\t * Clone this selection.\n\t */\n\tpublic clone(): Selection {\n\t\treturn new Selection(this.selectionStartLineNumber, this.selectionStartColumn, this.positionLineNumber, this.positionColumn);\n\t}\n\n\t/**\n\t * Transform to a human-readable representation.\n\t */\n\tpublic toString(): string {\n\t\treturn '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n\t}\n\n\t/**\n\t * Test if equals other selection.\n\t */\n\tpublic equalsSelection(other: ISelection): boolean {\n\t\treturn (\n\t\t\tSelection.selectionsEqual(this, other)\n\t\t);\n\t}\n\n\t/**\n\t * Test if the two selections are equal.\n\t */\n\tpublic static selectionsEqual(a: ISelection, b: ISelection): boolean {\n\t\treturn (\n\t\t\ta.selectionStartLineNumber === b.selectionStartLineNumber &&\n\t\t\ta.selectionStartColumn === b.selectionStartColumn &&\n\t\t\ta.positionLineNumber === b.positionLineNumber &&\n\t\t\ta.positionColumn === b.positionColumn\n\t\t);\n\t}\n\n\t/**\n\t * Get directions (LTR or RTL).\n\t */\n\tpublic getDirection(): SelectionDirection {\n\t\tif (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n\t\t\treturn SelectionDirection.LTR;\n\t\t}\n\t\treturn SelectionDirection.RTL;\n\t}\n\n\t/**\n\t * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n\t */\n\tpublic setEndPosition(endLineNumber: number, endColumn: number): Selection {\n\t\tif (this.getDirection() === SelectionDirection.LTR) {\n\t\t\treturn new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n\t\t}\n\t\treturn new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n\t}\n\n\t/**\n\t * Get the position at `positionLineNumber` and `positionColumn`.\n\t */\n\tpublic getPosition(): Position {\n\t\treturn new Position(this.positionLineNumber, this.positionColumn);\n\t}\n\n\t/**\n\t * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n\t */\n\tpublic setStartPosition(startLineNumber: number, startColumn: number): Selection {\n\t\tif (this.getDirection() === SelectionDirection.LTR) {\n\t\t\treturn new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n\t\t}\n\t\treturn new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n\t}\n\n\t// ----\n\n\t/**\n\t * Create a `Selection` from one or two positions\n\t */\n\tpublic static fromPositions(start: IPosition, end: IPosition = start): Selection {\n\t\treturn new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n\t}\n\n\t/**\n\t * Create a `Selection` from an `ISelection`.\n\t */\n\tpublic static liftSelection(sel: ISelection): Selection {\n\t\treturn new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n\t}\n\n\t/**\n\t * `a` equals `b`.\n\t */\n\tpublic static selectionsArrEqual(a: ISelection[], b: ISelection[]): boolean {\n\t\tif (a && !b || !a && b) {\n\t\t\treturn false;\n\t\t}\n\t\tif (!a && !b) {\n\t\t\treturn true;\n\t\t}\n\t\tif (a.length !== b.length) {\n\t\t\treturn false;\n\t\t}\n\t\tfor (let i = 0, len = a.length; i < len; i++) {\n\t\t\tif (!this.selectionsEqual(a[i], b[i])) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * Test if `obj` is an `ISelection`.\n\t */\n\tpublic static isISelection(obj: any): obj is ISelection {\n\t\treturn (\n\t\t\tobj\n\t\t\t&& (typeof obj.selectionStartLineNumber === 'number')\n\t\t\t&& (typeof obj.selectionStartColumn === 'number')\n\t\t\t&& (typeof obj.positionLineNumber === 'number')\n\t\t\t&& (typeof obj.positionColumn === 'number')\n\t\t);\n\t}\n\n\t/**\n\t * Create with a direction.\n\t */\n\tpublic static createWithDirection(startLineNumber: number, startColumn: number, endLineNumber: number, endColumn: number, direction: SelectionDirection): Selection {\n\n\t\tif (direction === SelectionDirection.LTR) {\n\t\t\treturn new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n\t\t}\n\n\t\treturn new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IState } from 'vs/editor/common/modes';\n\nexport class Token {\n\t_tokenBrand: void;\n\n\tpublic readonly offset: number;\n\tpublic readonly type: string;\n\tpublic readonly language: string;\n\n\tconstructor(offset: number, type: string, language: string) {\n\t\tthis.offset = offset | 0;// @perf\n\t\tthis.type = type;\n\t\tthis.language = language;\n\t}\n\n\tpublic toString(): string {\n\t\treturn '(' + this.offset + ', ' + this.type + ')';\n\t}\n}\n\nexport class TokenizationResult {\n\t_tokenizationResultBrand: void;\n\n\tpublic readonly tokens: Token[];\n\tpublic readonly endState: IState;\n\n\tconstructor(tokens: Token[], endState: IState) {\n\t\tthis.tokens = tokens;\n\t\tthis.endState = endState;\n\t}\n}\n\nexport class TokenizationResult2 {\n\t_tokenizationResult2Brand: void;\n\n\t/**\n\t * The tokens in binary format. Each token occupies two array indices. For token i:\n\t * - at offset 2*i => startIndex\n\t * - at offset 2*i + 1 => metadata\n\t *\n\t */\n\tpublic readonly tokens: Uint32Array;\n\tpublic readonly endState: IState;\n\n\tconstructor(tokens: Uint32Array, endState: IState) {\n\t\tthis.tokens = tokens;\n\t\tthis.endState = endState;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nexport class Uint8Matrix {\n\n\tprivate _data: Uint8Array;\n\tpublic readonly rows: number;\n\tpublic readonly cols: number;\n\n\tconstructor(rows: number, cols: number, defaultValue: number) {\n\t\tlet data = new Uint8Array(rows * cols);\n\t\tfor (let i = 0, len = rows * cols; i < len; i++) {\n\t\t\tdata[i] = defaultValue;\n\t\t}\n\n\t\tthis._data = data;\n\t\tthis.rows = rows;\n\t\tthis.cols = cols;\n\t}\n\n\tpublic get(row: number, col: number): number {\n\t\treturn this._data[row * this.cols + col];\n\t}\n\n\tpublic set(row: number, col: number, value: number): void {\n\t\tthis._data[row * this.cols + col] = value;\n\t}\n}\n\nexport const enum Constants {\n\t/**\n\t * MAX SMI (SMall Integer) as defined in v8.\n\t * one bit is lost for boxing/unboxing flag.\n\t * one bit is lost for sign flag.\n\t * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values\n\t */\n\tMAX_SAFE_SMALL_INTEGER = 1 << 30,\n\n\t/**\n\t * MIN SMI (SMall Integer) as defined in v8.\n\t * one bit is lost for boxing/unboxing flag.\n\t * one bit is lost for sign flag.\n\t * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values\n\t */\n\tMIN_SAFE_SMALL_INTEGER = -(1 << 30),\n\n\t/**\n\t * Max unsigned integer that fits on 8 bits.\n\t */\n\tMAX_UINT_8 = 255, // 2^8 - 1\n\n\t/**\n\t * Max unsigned integer that fits on 16 bits.\n\t */\n\tMAX_UINT_16 = 65535, // 2^16 - 1\n\n\t/**\n\t * Max unsigned integer that fits on 32 bits.\n\t */\n\tMAX_UINT_32 = 4294967295, // 2^32 - 1\n\n\n}\n\nexport function toUint8(v: number): number {\n\tif (v < 0) {\n\t\treturn 0;\n\t}\n\tif (v > Constants.MAX_UINT_8) {\n\t\treturn Constants.MAX_UINT_8;\n\t}\n\treturn v | 0;\n}\n\nexport function toUint32(v: number): number {\n\tif (v < 0) {\n\t\treturn 0;\n\t}\n\tif (v > Constants.MAX_UINT_32) {\n\t\treturn Constants.MAX_UINT_32;\n\t}\n\treturn v | 0;\n}\n\nexport function toUint32Array(arr: number[]): Uint32Array {\n\tlet len = arr.length;\n\tlet r = new Uint32Array(len);\n\tfor (let i = 0; i < len; i++) {\n\t\tr[i] = toUint32(arr[i]);\n\t}\n\treturn r;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { toUint8 } from 'vs/editor/common/core/uint';\n\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nexport class CharacterClassifier<T extends number> {\n\t/**\n\t * Maintain a compact (fully initialized ASCII map for quickly classifying ASCII characters - used more often in code).\n\t */\n\tprivate _asciiMap: Uint8Array;\n\n\t/**\n\t * The entire map (sparse array).\n\t */\n\tprivate _map: Map<number, number>;\n\n\tprivate _defaultValue: number;\n\n\tconstructor(_defaultValue: T) {\n\t\tlet defaultValue = toUint8(_defaultValue);\n\n\t\tthis._defaultValue = defaultValue;\n\t\tthis._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n\t\tthis._map = new Map<number, number>();\n\t}\n\n\tprivate static _createAsciiMap(defaultValue: number): Uint8Array {\n\t\tlet asciiMap: Uint8Array = new Uint8Array(256);\n\t\tfor (let i = 0; i < 256; i++) {\n\t\t\tasciiMap[i] = defaultValue;\n\t\t}\n\t\treturn asciiMap;\n\t}\n\n\tpublic set(charCode: number, _value: T): void {\n\t\tlet value = toUint8(_value);\n\n\t\tif (charCode >= 0 && charCode < 256) {\n\t\t\tthis._asciiMap[charCode] = value;\n\t\t} else {\n\t\t\tthis._map.set(charCode, value);\n\t\t}\n\t}\n\n\tpublic get(charCode: number): T {\n\t\tif (charCode >= 0 && charCode < 256) {\n\t\t\treturn <T>this._asciiMap[charCode];\n\t\t} else {\n\t\t\treturn <T>(this._map.get(charCode) || this._defaultValue);\n\t\t}\n\t}\n}\n\nconst enum Boolean {\n\tFalse = 0,\n\tTrue = 1\n}\n\nexport class CharacterSet {\n\n\tprivate _actual: CharacterClassifier<Boolean>;\n\n\tconstructor() {\n\t\tthis._actual = new CharacterClassifier<Boolean>(Boolean.False);\n\t}\n\n\tpublic add(charCode: number): void {\n\t\tthis._actual.set(charCode, Boolean.True);\n\t}\n\n\tpublic has(charCode: number): boolean {\n\t\treturn (this._actual.get(charCode) === Boolean.True);\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IDiffChange, ISequence, LcsDiff } from 'vs/base/common/diff/diff';\nimport * as strings from 'vs/base/common/strings';\nimport { ICharChange, ILineChange } from 'vs/editor/common/editorCommon';\n\nconst MAXIMUM_RUN_TIME = 5000; // 5 seconds\nconst MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\n\ninterface IMarker {\n\tlineNumber: number;\n\tcolumn: number;\n\toffset: number;\n}\n\nfunction computeDiff(originalSequence: ISequence, modifiedSequence: ISequence, continueProcessingPredicate: () => boolean, pretty: boolean): IDiffChange[] {\n\tconst diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n\treturn diffAlgo.ComputeDiff(pretty);\n}\n\nclass MarkerSequence implements ISequence {\n\n\tpublic buffer: string;\n\tpublic startMarkers: IMarker[];\n\tpublic endMarkers: IMarker[];\n\n\tconstructor(buffer: string, startMarkers: IMarker[], endMarkers: IMarker[]) {\n\t\tthis.buffer = buffer;\n\t\tthis.startMarkers = startMarkers;\n\t\tthis.endMarkers = endMarkers;\n\t}\n\n\tpublic getLength(): number {\n\t\treturn this.startMarkers.length;\n\t}\n\n\tpublic getElementHash(i: number): string {\n\t\treturn this.buffer.substring(this.startMarkers[i].offset, this.endMarkers[i].offset);\n\t}\n\n\tpublic getStartLineNumber(i: number): number {\n\t\tif (i === this.startMarkers.length) {\n\t\t\t// This is the special case where a change happened after the last marker\n\t\t\treturn this.startMarkers[i - 1].lineNumber + 1;\n\t\t}\n\t\treturn this.startMarkers[i].lineNumber;\n\t}\n\n\tpublic getStartColumn(i: number): number {\n\t\treturn this.startMarkers[i].column;\n\t}\n\n\tpublic getEndLineNumber(i: number): number {\n\t\treturn this.endMarkers[i].lineNumber;\n\t}\n\n\tpublic getEndColumn(i: number): number {\n\t\treturn this.endMarkers[i].column;\n\t}\n\n}\n\nclass LineMarkerSequence extends MarkerSequence {\n\n\tconstructor(lines: string[]) {\n\t\tlet buffer = '';\n\t\tlet startMarkers: IMarker[] = [];\n\t\tlet endMarkers: IMarker[] = [];\n\n\t\tfor (let pos = 0, i = 0, length = lines.length; i < length; i++) {\n\t\t\tbuffer += lines[i];\n\t\t\tconst startColumn = LineMarkerSequence._getFirstNonBlankColumn(lines[i], 1);\n\t\t\tconst endColumn = LineMarkerSequence._getLastNonBlankColumn(lines[i], 1);\n\n\t\t\tstartMarkers.push({\n\t\t\t\toffset: pos + startColumn - 1,\n\t\t\t\tlineNumber: i + 1,\n\t\t\t\tcolumn: startColumn\n\t\t\t});\n\n\t\t\tendMarkers.push({\n\t\t\t\toffset: pos + endColumn - 1,\n\t\t\t\tlineNumber: i + 1,\n\t\t\t\tcolumn: endColumn\n\t\t\t});\n\n\t\t\tpos += lines[i].length;\n\t\t}\n\n\t\tsuper(buffer, startMarkers, endMarkers);\n\t}\n\n\tpublic static _getFirstNonBlankColumn(txt: string, defaultValue: number): number {\n\t\tconst r = strings.firstNonWhitespaceIndex(txt);\n\t\tif (r === -1) {\n\t\t\treturn defaultValue;\n\t\t}\n\t\treturn r + 1;\n\t}\n\n\tpublic static _getLastNonBlankColumn(txt: string, defaultValue: number): number {\n\t\tconst r = strings.lastNonWhitespaceIndex(txt);\n\t\tif (r === -1) {\n\t\t\treturn defaultValue;\n\t\t}\n\t\treturn r + 2;\n\t}\n\n\tpublic getCharSequence(startIndex: number, endIndex: number): MarkerSequence {\n\t\tlet startMarkers: IMarker[] = [];\n\t\tlet endMarkers: IMarker[] = [];\n\t\tfor (let index = startIndex; index <= endIndex; index++) {\n\t\t\tconst startMarker = this.startMarkers[index];\n\t\t\tconst endMarker = this.endMarkers[index];\n\t\t\tfor (let i = startMarker.offset; i < endMarker.offset; i++) {\n\t\t\t\tstartMarkers.push({\n\t\t\t\t\toffset: i,\n\t\t\t\t\tlineNumber: startMarker.lineNumber,\n\t\t\t\t\tcolumn: startMarker.column + (i - startMarker.offset)\n\t\t\t\t});\n\t\t\t\tendMarkers.push({\n\t\t\t\t\toffset: i + 1,\n\t\t\t\t\tlineNumber: startMarker.lineNumber,\n\t\t\t\t\tcolumn: startMarker.column + (i - startMarker.offset) + 1\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn new MarkerSequence(this.buffer, startMarkers, endMarkers);\n\t}\n}\n\nclass CharChange implements ICharChange {\n\n\tpublic originalStartLineNumber: number;\n\tpublic originalStartColumn: number;\n\tpublic originalEndLineNumber: number;\n\tpublic originalEndColumn: number;\n\n\tpublic modifiedStartLineNumber: number;\n\tpublic modifiedStartColumn: number;\n\tpublic modifiedEndLineNumber: number;\n\tpublic modifiedEndColumn: number;\n\n\tconstructor(\n\t\toriginalStartLineNumber: number,\n\t\toriginalStartColumn: number,\n\t\toriginalEndLineNumber: number,\n\t\toriginalEndColumn: number,\n\t\tmodifiedStartLineNumber: number,\n\t\tmodifiedStartColumn: number,\n\t\tmodifiedEndLineNumber: number,\n\t\tmodifiedEndColumn: number\n\t) {\n\t\tthis.originalStartLineNumber = originalStartLineNumber;\n\t\tthis.originalStartColumn = originalStartColumn;\n\t\tthis.originalEndLineNumber = originalEndLineNumber;\n\t\tthis.originalEndColumn = originalEndColumn;\n\t\tthis.modifiedStartLineNumber = modifiedStartLineNumber;\n\t\tthis.modifiedStartColumn = modifiedStartColumn;\n\t\tthis.modifiedEndLineNumber = modifiedEndLineNumber;\n\t\tthis.modifiedEndColumn = modifiedEndColumn;\n\t}\n\n\tpublic static createFromDiffChange(diffChange: IDiffChange, originalCharSequence: MarkerSequence, modifiedCharSequence: MarkerSequence): CharChange {\n\t\tlet originalStartLineNumber: number;\n\t\tlet originalStartColumn: number;\n\t\tlet originalEndLineNumber: number;\n\t\tlet originalEndColumn: number;\n\t\tlet modifiedStartLineNumber: number;\n\t\tlet modifiedStartColumn: number;\n\t\tlet modifiedEndLineNumber: number;\n\t\tlet modifiedEndColumn: number;\n\n\t\tif (diffChange.originalLength === 0) {\n\t\t\toriginalStartLineNumber = 0;\n\t\t\toriginalStartColumn = 0;\n\t\t\toriginalEndLineNumber = 0;\n\t\t\toriginalEndColumn = 0;\n\t\t} else {\n\t\t\toriginalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n\t\t\toriginalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n\t\t\toriginalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n\t\t\toriginalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n\t\t}\n\n\t\tif (diffChange.modifiedLength === 0) {\n\t\t\tmodifiedStartLineNumber = 0;\n\t\t\tmodifiedStartColumn = 0;\n\t\t\tmodifiedEndLineNumber = 0;\n\t\t\tmodifiedEndColumn = 0;\n\t\t} else {\n\t\t\tmodifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n\t\t\tmodifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n\t\t\tmodifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n\t\t\tmodifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n\t\t}\n\n\t\treturn new CharChange(\n\t\t\toriginalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn,\n\t\t\tmodifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn,\n\t\t);\n\t}\n}\n\nfunction postProcessCharChanges(rawChanges: IDiffChange[]): IDiffChange[] {\n\tif (rawChanges.length <= 1) {\n\t\treturn rawChanges;\n\t}\n\n\tlet result = [rawChanges[0]];\n\tlet prevChange = result[0];\n\n\tfor (let i = 1, len = rawChanges.length; i < len; i++) {\n\t\tconst currChange = rawChanges[i];\n\n\t\tconst originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n\t\tconst modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n\t\t// Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n\t\tconst matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n\n\t\tif (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n\t\t\t// Merge the current change into the previous one\n\t\t\tprevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n\t\t\tprevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n\t\t} else {\n\t\t\t// Add the current change\n\t\t\tresult.push(currChange);\n\t\t\tprevChange = currChange;\n\t\t}\n\t}\n\n\treturn result;\n}\n\nclass LineChange implements ILineChange {\n\tpublic originalStartLineNumber: number;\n\tpublic originalEndLineNumber: number;\n\tpublic modifiedStartLineNumber: number;\n\tpublic modifiedEndLineNumber: number;\n\tpublic charChanges: CharChange[];\n\n\tconstructor(\n\t\toriginalStartLineNumber: number,\n\t\toriginalEndLineNumber: number,\n\t\tmodifiedStartLineNumber: number,\n\t\tmodifiedEndLineNumber: number,\n\t\tcharChanges: CharChange[]\n\t) {\n\t\tthis.originalStartLineNumber = originalStartLineNumber;\n\t\tthis.originalEndLineNumber = originalEndLineNumber;\n\t\tthis.modifiedStartLineNumber = modifiedStartLineNumber;\n\t\tthis.modifiedEndLineNumber = modifiedEndLineNumber;\n\t\tthis.charChanges = charChanges;\n\t}\n\n\tpublic static createFromDiffResult(diffChange: IDiffChange, originalLineSequence: LineMarkerSequence, modifiedLineSequence: LineMarkerSequence, continueProcessingPredicate: () => boolean, shouldPostProcessCharChanges: boolean): LineChange {\n\t\tlet originalStartLineNumber: number;\n\t\tlet originalEndLineNumber: number;\n\t\tlet modifiedStartLineNumber: number;\n\t\tlet modifiedEndLineNumber: number;\n\t\tlet charChanges: CharChange[];\n\n\t\tif (diffChange.originalLength === 0) {\n\t\t\toriginalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n\t\t\toriginalEndLineNumber = 0;\n\t\t} else {\n\t\t\toriginalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n\t\t\toriginalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n\t\t}\n\n\t\tif (diffChange.modifiedLength === 0) {\n\t\t\tmodifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n\t\t\tmodifiedEndLineNumber = 0;\n\t\t} else {\n\t\t\tmodifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n\t\t\tmodifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n\t\t}\n\n\t\tif (diffChange.originalLength !== 0 && diffChange.modifiedLength !== 0 && continueProcessingPredicate()) {\n\t\t\tconst originalCharSequence = originalLineSequence.getCharSequence(diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n\t\t\tconst modifiedCharSequence = modifiedLineSequence.getCharSequence(diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n\n\t\t\tlet rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueProcessingPredicate, true);\n\n\t\t\tif (shouldPostProcessCharChanges) {\n\t\t\t\trawChanges = postProcessCharChanges(rawChanges);\n\t\t\t}\n\n\t\t\tcharChanges = [];\n\t\t\tfor (let i = 0, length = rawChanges.length; i < length; i++) {\n\t\t\t\tcharChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n\t\t\t}\n\t\t}\n\n\t\treturn new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n\t}\n}\n\nexport interface IDiffComputerOpts {\n\tshouldPostProcessCharChanges: boolean;\n\tshouldIgnoreTrimWhitespace: boolean;\n\tshouldMakePrettyDiff: boolean;\n}\n\nexport class DiffComputer {\n\n\tprivate readonly shouldPostProcessCharChanges: boolean;\n\tprivate readonly shouldIgnoreTrimWhitespace: boolean;\n\tprivate readonly shouldMakePrettyDiff: boolean;\n\tprivate readonly maximumRunTimeMs: number;\n\tprivate readonly originalLines: string[];\n\tprivate readonly modifiedLines: string[];\n\tprivate readonly original: LineMarkerSequence;\n\tprivate readonly modified: LineMarkerSequence;\n\n\tprivate computationStartTime: number;\n\n\tconstructor(originalLines: string[], modifiedLines: string[], opts: IDiffComputerOpts) {\n\t\tthis.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n\t\tthis.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n\t\tthis.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n\t\tthis.maximumRunTimeMs = MAXIMUM_RUN_TIME;\n\t\tthis.originalLines = originalLines;\n\t\tthis.modifiedLines = modifiedLines;\n\t\tthis.original = new LineMarkerSequence(originalLines);\n\t\tthis.modified = new LineMarkerSequence(modifiedLines);\n\t}\n\n\tpublic computeDiff(): ILineChange[] {\n\n\t\tif (this.original.getLength() === 1 && this.original.getElementHash(0).length === 0) {\n\t\t\t// empty original => fast path\n\t\t\treturn [{\n\t\t\t\toriginalStartLineNumber: 1,\n\t\t\t\toriginalEndLineNumber: 1,\n\t\t\t\tmodifiedStartLineNumber: 1,\n\t\t\t\tmodifiedEndLineNumber: this.modified.getLength(),\n\t\t\t\tcharChanges: [{\n\t\t\t\t\tmodifiedEndColumn: 0,\n\t\t\t\t\tmodifiedEndLineNumber: 0,\n\t\t\t\t\tmodifiedStartColumn: 0,\n\t\t\t\t\tmodifiedStartLineNumber: 0,\n\t\t\t\t\toriginalEndColumn: 0,\n\t\t\t\t\toriginalEndLineNumber: 0,\n\t\t\t\t\toriginalStartColumn: 0,\n\t\t\t\t\toriginalStartLineNumber: 0\n\t\t\t\t}]\n\t\t\t}];\n\t\t}\n\n\t\tif (this.modified.getLength() === 1 && this.modified.getElementHash(0).length === 0) {\n\t\t\t// empty modified => fast path\n\t\t\treturn [{\n\t\t\t\toriginalStartLineNumber: 1,\n\t\t\t\toriginalEndLineNumber: this.original.getLength(),\n\t\t\t\tmodifiedStartLineNumber: 1,\n\t\t\t\tmodifiedEndLineNumber: 1,\n\t\t\t\tcharChanges: [{\n\t\t\t\t\tmodifiedEndColumn: 0,\n\t\t\t\t\tmodifiedEndLineNumber: 0,\n\t\t\t\t\tmodifiedStartColumn: 0,\n\t\t\t\t\tmodifiedStartLineNumber: 0,\n\t\t\t\t\toriginalEndColumn: 0,\n\t\t\t\t\toriginalEndLineNumber: 0,\n\t\t\t\t\toriginalStartColumn: 0,\n\t\t\t\t\toriginalStartLineNumber: 0\n\t\t\t\t}]\n\t\t\t}];\n\t\t}\n\n\t\tthis.computationStartTime = (new Date()).getTime();\n\n\t\tlet rawChanges = computeDiff(this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldMakePrettyDiff);\n\n\t\t// The diff is always computed with ignoring trim whitespace\n\t\t// This ensures we get the prettiest diff\n\n\t\tif (this.shouldIgnoreTrimWhitespace) {\n\t\t\tlet lineChanges: LineChange[] = [];\n\t\t\tfor (let i = 0, length = rawChanges.length; i < length; i++) {\n\t\t\t\tlineChanges.push(LineChange.createFromDiffResult(rawChanges[i], this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldPostProcessCharChanges));\n\t\t\t}\n\t\t\treturn lineChanges;\n\t\t}\n\n\t\t// Need to post-process and introduce changes where the trim whitespace is different\n\t\t// Note that we are looping starting at -1 to also cover the lines before the first change\n\t\tlet result: LineChange[] = [];\n\n\t\tlet originalLineIndex = 0;\n\t\tlet modifiedLineIndex = 0;\n\t\tfor (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n\t\t\tconst nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n\t\t\tconst originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n\t\t\tconst modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n\n\t\t\twhile (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n\t\t\t\tconst originalLine = this.originalLines[originalLineIndex];\n\t\t\t\tconst modifiedLine = this.modifiedLines[modifiedLineIndex];\n\n\t\t\t\tif (originalLine !== modifiedLine) {\n\t\t\t\t\t// These lines differ only in trim whitespace\n\n\t\t\t\t\t// Check the leading whitespace\n\t\t\t\t\t{\n\t\t\t\t\t\tlet originalStartColumn = LineMarkerSequence._getFirstNonBlankColumn(originalLine, 1);\n\t\t\t\t\t\tlet modifiedStartColumn = LineMarkerSequence._getFirstNonBlankColumn(modifiedLine, 1);\n\t\t\t\t\t\twhile (originalStartColumn > 1 && modifiedStartColumn > 1) {\n\t\t\t\t\t\t\tconst originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n\t\t\t\t\t\t\tconst modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n\t\t\t\t\t\t\tif (originalChar !== modifiedChar) {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\toriginalStartColumn--;\n\t\t\t\t\t\t\tmodifiedStartColumn--;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (originalStartColumn > 1 || modifiedStartColumn > 1) {\n\t\t\t\t\t\t\tthis._pushTrimWhitespaceCharChange(result,\n\t\t\t\t\t\t\t\toriginalLineIndex + 1, 1, originalStartColumn,\n\t\t\t\t\t\t\t\tmodifiedLineIndex + 1, 1, modifiedStartColumn\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check the trailing whitespace\n\t\t\t\t\t{\n\t\t\t\t\t\tlet originalEndColumn = LineMarkerSequence._getLastNonBlankColumn(originalLine, 1);\n\t\t\t\t\t\tlet modifiedEndColumn = LineMarkerSequence._getLastNonBlankColumn(modifiedLine, 1);\n\t\t\t\t\t\tconst originalMaxColumn = originalLine.length + 1;\n\t\t\t\t\t\tconst modifiedMaxColumn = modifiedLine.length + 1;\n\t\t\t\t\t\twhile (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n\t\t\t\t\t\t\tconst originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n\t\t\t\t\t\t\tconst modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n\t\t\t\t\t\t\tif (originalChar !== modifiedChar) {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\toriginalEndColumn++;\n\t\t\t\t\t\t\tmodifiedEndColumn++;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n\t\t\t\t\t\t\tthis._pushTrimWhitespaceCharChange(result,\n\t\t\t\t\t\t\t\toriginalLineIndex + 1, originalEndColumn, originalMaxColumn,\n\t\t\t\t\t\t\t\tmodifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\toriginalLineIndex++;\n\t\t\t\tmodifiedLineIndex++;\n\t\t\t}\n\n\t\t\tif (nextChange) {\n\t\t\t\t// Emit the actual change\n\t\t\t\tresult.push(LineChange.createFromDiffResult(nextChange, this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldPostProcessCharChanges));\n\n\t\t\t\toriginalLineIndex += nextChange.originalLength;\n\t\t\t\tmodifiedLineIndex += nextChange.modifiedLength;\n\t\t\t}\n\t\t}\n\n\t\treturn result;\n\t}\n\n\tprivate _pushTrimWhitespaceCharChange(\n\t\tresult: LineChange[],\n\t\toriginalLineNumber: number, originalStartColumn: number, originalEndColumn: number,\n\t\tmodifiedLineNumber: number, modifiedStartColumn: number, modifiedEndColumn: number\n\t): void {\n\t\tif (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n\t\t\t// Merged into previous\n\t\t\treturn;\n\t\t}\n\n\t\tresult.push(new LineChange(\n\t\t\toriginalLineNumber, originalLineNumber,\n\t\t\tmodifiedLineNumber, modifiedLineNumber,\n\t\t\t[\n\t\t\t\tnew CharChange(\n\t\t\t\t\toriginalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn,\n\t\t\t\t\tmodifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn\n\t\t\t\t)\n\t\t\t]\n\t\t));\n\t}\n\n\tprivate _mergeTrimWhitespaceCharChange(\n\t\tresult: LineChange[],\n\t\toriginalLineNumber: number, originalStartColumn: number, originalEndColumn: number,\n\t\tmodifiedLineNumber: number, modifiedStartColumn: number, modifiedEndColumn: number\n\t): boolean {\n\t\tconst len = result.length;\n\t\tif (len === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst prevChange = result[len - 1];\n\n\t\tif (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n\t\t\t// Don't merge with inserts/deletes\n\t\t\treturn false;\n\t\t}\n\n\t\tif (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n\t\t\tprevChange.originalEndLineNumber = originalLineNumber;\n\t\t\tprevChange.modifiedEndLineNumber = modifiedLineNumber;\n\t\t\tprevChange.charChanges.push(new CharChange(\n\t\t\t\toriginalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn,\n\t\t\t\tmodifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn\n\t\t\t));\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tprivate _continueProcessingPredicate(): boolean {\n\t\tif (this.maximumRunTimeMs === 0) {\n\t\t\treturn true;\n\t\t}\n\t\tconst now = (new Date()).getTime();\n\t\treturn now - this.computationStartTime < this.maximumRunTimeMs;\n\t}\n\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IWordAtPosition } from 'vs/editor/common/model';\n\nexport const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n\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: string = ''): RegExp {\n\tlet source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n\tfor (let i = 0; i < USUAL_WORD_SEPARATORS.length; i++) {\n\t\tif (allowInWords.indexOf(USUAL_WORD_SEPARATORS[i]) >= 0) {\n\t\t\tcontinue;\n\t\t}\n\t\tsource += '\\\\' + USUAL_WORD_SEPARATORS[i];\n\t}\n\tsource += '\\\\s]+)';\n\treturn new RegExp(source, 'g');\n}\n\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport const DEFAULT_WORD_REGEXP = createWordRegExp();\n\nexport function ensureValidWordDefinition(wordDefinition?: RegExp): RegExp {\n\tlet result: RegExp = DEFAULT_WORD_REGEXP;\n\n\tif (wordDefinition && (wordDefinition instanceof RegExp)) {\n\t\tif (!wordDefinition.global) {\n\t\t\tlet flags = 'g';\n\t\t\tif (wordDefinition.ignoreCase) {\n\t\t\t\tflags += 'i';\n\t\t\t}\n\t\t\tif (wordDefinition.multiline) {\n\t\t\t\tflags += 'm';\n\t\t\t}\n\t\t\tresult = new RegExp(wordDefinition.source, flags);\n\t\t} else {\n\t\t\tresult = wordDefinition;\n\t\t}\n\t}\n\n\tresult.lastIndex = 0;\n\n\treturn result;\n}\n\nfunction getWordAtPosFast(column: number, wordDefinition: RegExp, text: string, textOffset: number): IWordAtPosition {\n\t// find whitespace enclosed text around column and match from there\n\n\tlet pos = column - 1 - textOffset;\n\tlet start = text.lastIndexOf(' ', pos - 1) + 1;\n\tlet end = text.indexOf(' ', pos);\n\tif (end === -1) {\n\t\tend = text.length;\n\t}\n\n\twordDefinition.lastIndex = start;\n\tlet match: RegExpMatchArray;\n\twhile (match = wordDefinition.exec(text)) {\n\t\tif (match.index <= pos && wordDefinition.lastIndex >= pos) {\n\t\t\treturn {\n\t\t\t\tword: match[0],\n\t\t\t\tstartColumn: textOffset + 1 + match.index,\n\t\t\t\tendColumn: textOffset + 1 + wordDefinition.lastIndex\n\t\t\t};\n\t\t}\n\t}\n\n\treturn null;\n}\n\n\nfunction getWordAtPosSlow(column: number, wordDefinition: RegExp, text: string, textOffset: number): IWordAtPosition {\n\t// matches all words starting at the beginning\n\t// of the input until it finds a match that encloses\n\t// the desired column. slow but correct\n\n\tlet pos = column - 1 - textOffset;\n\twordDefinition.lastIndex = 0;\n\n\tlet match: RegExpMatchArray;\n\twhile (match = wordDefinition.exec(text)) {\n\n\t\tif (match.index > pos) {\n\t\t\t// |nW -> matched only after the pos\n\t\t\treturn null;\n\n\t\t} else if (wordDefinition.lastIndex >= pos) {\n\t\t\t// W|W -> match encloses pos\n\t\t\treturn {\n\t\t\t\tword: match[0],\n\t\t\t\tstartColumn: textOffset + 1 + match.index,\n\t\t\t\tendColumn: textOffset + 1 + wordDefinition.lastIndex\n\t\t\t};\n\t\t}\n\t}\n\n\treturn null;\n}\n\nexport function getWordAtText(column: number, wordDefinition: RegExp, text: string, textOffset: number): IWordAtPosition {\n\n\t// if `words` can contain whitespace character we have to use the slow variant\n\t// otherwise we use the fast variant of finding a word\n\twordDefinition.lastIndex = 0;\n\tlet match = wordDefinition.exec(text);\n\tif (!match) {\n\t\treturn null;\n\t}\n\t// todo@joh the `match` could already be the (first) word\n\tconst ret = match[0].indexOf(' ') >= 0\n\t\t// did match a word which contains a space character -> use slow word find\n\t\t? getWordAtPosSlow(column, wordDefinition, text, textOffset)\n\t\t// sane word definition -> use fast word find\n\t\t: getWordAtPosFast(column, wordDefinition, text, textOffset);\n\n\t// both (getWordAtPosFast and getWordAtPosSlow) leave the wordDefinition-RegExp\n\t// in an undefined state and to not confuse other users of the wordDefinition\n\t// we reset the lastIndex\n\twordDefinition.lastIndex = 0;\n\n\treturn ret;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { ILink } from 'vs/editor/common/modes';\nimport { CharCode } from 'vs/base/common/charCode';\nimport { CharacterClassifier } from 'vs/editor/common/core/characterClassifier';\nimport { Uint8Matrix } from 'vs/editor/common/core/uint';\n\nexport interface ILinkComputerTarget {\n\tgetLineCount(): number;\n\tgetLineContent(lineNumber: number): string;\n}\n\nconst enum State {\n\tInvalid = 0,\n\tStart = 1,\n\tH = 2,\n\tHT = 3,\n\tHTT = 4,\n\tHTTP = 5,\n\tF = 6,\n\tFI = 7,\n\tFIL = 8,\n\tBeforeColon = 9,\n\tAfterColon = 10,\n\tAlmostThere = 11,\n\tEnd = 12,\n\tAccept = 13\n}\n\ntype Edge = [State, number, State];\n\nclass StateMachine {\n\n\tprivate _states: Uint8Matrix;\n\tprivate _maxCharCode: number;\n\n\tconstructor(edges: Edge[]) {\n\t\tlet maxCharCode = 0;\n\t\tlet maxState = State.Invalid;\n\t\tfor (let i = 0, len = edges.length; i < len; i++) {\n\t\t\tlet [from, chCode, to] = edges[i];\n\t\t\tif (chCode > maxCharCode) {\n\t\t\t\tmaxCharCode = chCode;\n\t\t\t}\n\t\t\tif (from > maxState) {\n\t\t\t\tmaxState = from;\n\t\t\t}\n\t\t\tif (to > maxState) {\n\t\t\t\tmaxState = to;\n\t\t\t}\n\t\t}\n\n\t\tmaxCharCode++;\n\t\tmaxState++;\n\n\t\tlet states = new Uint8Matrix(maxState, maxCharCode, State.Invalid);\n\t\tfor (let i = 0, len = edges.length; i < len; i++) {\n\t\t\tlet [from, chCode, to] = edges[i];\n\t\t\tstates.set(from, chCode, to);\n\t\t}\n\n\t\tthis._states = states;\n\t\tthis._maxCharCode = maxCharCode;\n\t}\n\n\tpublic nextState(currentState: State, chCode: number): State {\n\t\tif (chCode < 0 || chCode >= this._maxCharCode) {\n\t\t\treturn State.Invalid;\n\t\t}\n\t\treturn this._states.get(currentState, chCode);\n\t}\n}\n\n// State machine for http:// or https:// or file://\nlet _stateMachine: StateMachine = null;\nfunction getStateMachine(): StateMachine {\n\tif (_stateMachine === null) {\n\t\t_stateMachine = new StateMachine([\n\t\t\t[State.Start, CharCode.h, State.H],\n\t\t\t[State.Start, CharCode.H, State.H],\n\t\t\t[State.Start, CharCode.f, State.F],\n\t\t\t[State.Start, CharCode.F, State.F],\n\n\t\t\t[State.H, CharCode.t, State.HT],\n\t\t\t[State.H, CharCode.T, State.HT],\n\n\t\t\t[State.HT, CharCode.t, State.HTT],\n\t\t\t[State.HT, CharCode.T, State.HTT],\n\n\t\t\t[State.HTT, CharCode.p, State.HTTP],\n\t\t\t[State.HTT, CharCode.P, State.HTTP],\n\n\t\t\t[State.HTTP, CharCode.s, State.BeforeColon],\n\t\t\t[State.HTTP, CharCode.S, State.BeforeColon],\n\t\t\t[State.HTTP, CharCode.Colon, State.AfterColon],\n\n\t\t\t[State.F, CharCode.i, State.FI],\n\t\t\t[State.F, CharCode.I, State.FI],\n\n\t\t\t[State.FI, CharCode.l, State.FIL],\n\t\t\t[State.FI, CharCode.L, State.FIL],\n\n\t\t\t[State.FIL, CharCode.e, State.BeforeColon],\n\t\t\t[State.FIL, CharCode.E, State.BeforeColon],\n\n\t\t\t[State.BeforeColon, CharCode.Colon, State.AfterColon],\n\n\t\t\t[State.AfterColon, CharCode.Slash, State.AlmostThere],\n\n\t\t\t[State.AlmostThere, CharCode.Slash, State.End],\n\t\t]);\n\t}\n\treturn _stateMachine;\n}\n\n\nconst enum CharacterClass {\n\tNone = 0,\n\tForceTermination = 1,\n\tCannotEndIn = 2\n}\n\nlet _classifier: CharacterClassifier<CharacterClass> = null;\nfunction getClassifier(): CharacterClassifier<CharacterClass> {\n\tif (_classifier === null) {\n\t\t_classifier = new CharacterClassifier<CharacterClass>(CharacterClass.None);\n\n\t\tconst FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…';\n\t\tfor (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n\t\t\t_classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), CharacterClass.ForceTermination);\n\t\t}\n\n\t\tconst CANNOT_END_WITH_CHARACTERS = '.,;';\n\t\tfor (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n\t\t\t_classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), CharacterClass.CannotEndIn);\n\t\t}\n\t}\n\treturn _classifier;\n}\n\nclass LinkComputer {\n\n\tprivate static _createLink(classifier: CharacterClassifier<CharacterClass>, line: string, lineNumber: number, linkBeginIndex: number, linkEndIndex: number): ILink {\n\t\t// Do not allow to end link in certain characters...\n\t\tlet lastIncludedCharIndex = linkEndIndex - 1;\n\t\tdo {\n\t\t\tconst chCode = line.charCodeAt(lastIncludedCharIndex);\n\t\t\tconst chClass = classifier.get(chCode);\n\t\t\tif (chClass !== CharacterClass.CannotEndIn) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tlastIncludedCharIndex--;\n\t\t} while (lastIncludedCharIndex > linkBeginIndex);\n\n\t\t// Handle links enclosed in parens, square brackets and curlys.\n\t\tif (linkBeginIndex > 0) {\n\t\t\tconst charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n\t\t\tconst lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n\n\t\t\tif (\n\t\t\t\t(charCodeBeforeLink === CharCode.OpenParen && lastCharCodeInLink === CharCode.CloseParen)\n\t\t\t\t|| (charCodeBeforeLink === CharCode.OpenSquareBracket && lastCharCodeInLink === CharCode.CloseSquareBracket)\n\t\t\t\t|| (charCodeBeforeLink === CharCode.OpenCurlyBrace && lastCharCodeInLink === CharCode.CloseCurlyBrace)\n\t\t\t) {\n\t\t\t\t// Do not end in ) if ( is before the link start\n\t\t\t\t// Do not end in ] if [ is before the link start\n\t\t\t\t// Do not end in } if { is before the link start\n\t\t\t\tlastIncludedCharIndex--;\n\t\t\t}\n\t\t}\n\n\t\treturn {\n\t\t\trange: {\n\t\t\t\tstartLineNumber: lineNumber,\n\t\t\t\tstartColumn: linkBeginIndex + 1,\n\t\t\t\tendLineNumber: lineNumber,\n\t\t\t\tendColumn: lastIncludedCharIndex + 2\n\t\t\t},\n\t\t\turl: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n\t\t};\n\t}\n\n\tpublic static computeLinks(model: ILinkComputerTarget): ILink[] {\n\t\tconst stateMachine = getStateMachine();\n\t\tconst classifier = getClassifier();\n\n\t\tlet result: ILink[] = [];\n\t\tfor (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n\t\t\tconst line = model.getLineContent(i);\n\t\t\tconst len = line.length;\n\n\t\t\tlet j = 0;\n\t\t\tlet linkBeginIndex = 0;\n\t\t\tlet linkBeginChCode = 0;\n\t\t\tlet state = State.Start;\n\t\t\tlet hasOpenParens = false;\n\t\t\tlet hasOpenSquareBracket = false;\n\t\t\tlet hasOpenCurlyBracket = false;\n\n\t\t\twhile (j < len) {\n\n\t\t\t\tlet resetStateMachine = false;\n\t\t\t\tconst chCode = line.charCodeAt(j);\n\n\t\t\t\tif (state === State.Accept) {\n\t\t\t\t\tlet chClass: CharacterClass;\n\t\t\t\t\tswitch (chCode) {\n\t\t\t\t\t\tcase CharCode.OpenParen:\n\t\t\t\t\t\t\thasOpenParens = true;\n\t\t\t\t\t\t\tchClass = CharacterClass.None;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.CloseParen:\n\t\t\t\t\t\t\tchClass = (hasOpenParens ? CharacterClass.None : CharacterClass.ForceTermination);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.OpenSquareBracket:\n\t\t\t\t\t\t\thasOpenSquareBracket = true;\n\t\t\t\t\t\t\tchClass = CharacterClass.None;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.CloseSquareBracket:\n\t\t\t\t\t\t\tchClass = (hasOpenSquareBracket ? CharacterClass.None : CharacterClass.ForceTermination);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.OpenCurlyBrace:\n\t\t\t\t\t\t\thasOpenCurlyBracket = true;\n\t\t\t\t\t\t\tchClass = CharacterClass.None;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.CloseCurlyBrace:\n\t\t\t\t\t\t\tchClass = (hasOpenCurlyBracket ? CharacterClass.None : CharacterClass.ForceTermination);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t/* The following three rules make it that ' or \" or ` are allowed inside links if the link began with a different one */\n\t\t\t\t\t\tcase CharCode.SingleQuote:\n\t\t\t\t\t\t\tchClass = (linkBeginChCode === CharCode.DoubleQuote || linkBeginChCode === CharCode.BackTick) ? CharacterClass.None : CharacterClass.ForceTermination;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.DoubleQuote:\n\t\t\t\t\t\t\tchClass = (linkBeginChCode === CharCode.SingleQuote || linkBeginChCode === CharCode.BackTick) ? CharacterClass.None : CharacterClass.ForceTermination;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase CharCode.BackTick:\n\t\t\t\t\t\t\tchClass = (linkBeginChCode === CharCode.SingleQuote || linkBeginChCode === CharCode.DoubleQuote) ? CharacterClass.None : CharacterClass.ForceTermination;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tchClass = classifier.get(chCode);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check if character terminates link\n\t\t\t\t\tif (chClass === CharacterClass.ForceTermination) {\n\t\t\t\t\t\tresult.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n\t\t\t\t\t\tresetStateMachine = true;\n\t\t\t\t\t}\n\t\t\t\t} else if (state === State.End) {\n\t\t\t\t\tconst chClass = classifier.get(chCode);\n\n\t\t\t\t\t// Check if character terminates link\n\t\t\t\t\tif (chClass === CharacterClass.ForceTermination) {\n\t\t\t\t\t\tresetStateMachine = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = State.Accept;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tstate = stateMachine.nextState(state, chCode);\n\t\t\t\t\tif (state === State.Invalid) {\n\t\t\t\t\t\tresetStateMachine = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (resetStateMachine) {\n\t\t\t\t\tstate = State.Start;\n\t\t\t\t\thasOpenParens = false;\n\t\t\t\t\thasOpenSquareBracket = false;\n\t\t\t\t\thasOpenCurlyBracket = false;\n\n\t\t\t\t\t// Record where the link started\n\t\t\t\t\tlinkBeginIndex = j + 1;\n\t\t\t\t\tlinkBeginChCode = chCode;\n\t\t\t\t}\n\n\t\t\t\tj++;\n\t\t\t}\n\n\t\t\tif (state === State.Accept) {\n\t\t\t\tresult.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n\t\t\t}\n\n\t\t}\n\n\t\treturn result;\n\t}\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: ILinkComputerTarget): ILink[] {\n\tif (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n\t\t// Unknown caller!\n\t\treturn [];\n\t}\n\treturn 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 *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { IInplaceReplaceSupportResult } from 'vs/editor/common/modes';\nimport { IRange } from 'vs/editor/common/core/range';\n\nexport class BasicInplaceReplace {\n\n\tpublic static readonly INSTANCE = new BasicInplaceReplace();\n\n\tpublic navigateValueSet(range1: IRange, text1: string, range2: IRange, text2: string, up: boolean): IInplaceReplaceSupportResult {\n\n\t\tif (range1 && text1) {\n\t\t\tlet result = this.doNavigateValueSet(text1, up);\n\t\t\tif (result) {\n\t\t\t\treturn {\n\t\t\t\t\trange: range1,\n\t\t\t\t\tvalue: result\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif (range2 && text2) {\n\t\t\tlet result = this.doNavigateValueSet(text2, up);\n\t\t\tif (result) {\n\t\t\t\treturn {\n\t\t\t\t\trange: range2,\n\t\t\t\t\tvalue: result\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tprivate doNavigateValueSet(text: string, up: boolean): string {\n\t\tlet numberResult = this.numberReplace(text, up);\n\t\tif (numberResult !== null) {\n\t\t\treturn numberResult;\n\t\t}\n\t\treturn this.textReplace(text, up);\n\t}\n\n\tprivate numberReplace(value: string, up: boolean): string {\n\t\tlet precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n\t\tlet n1 = Number(value);\n\t\tlet n2 = parseFloat(value);\n\n\t\tif (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n\n\t\t\tif (n1 === 0 && !up) {\n\t\t\t\treturn null; // don't do negative\n\t\t\t\t//\t\t\t} else if(n1 === 9 && up) {\n\t\t\t\t//\t\t\t\treturn null; // don't insert 10 into a number\n\t\t\t} else {\n\t\t\t\tn1 = Math.floor(n1 * precision);\n\t\t\t\tn1 += up ? precision : -precision;\n\t\t\t\treturn String(n1 / precision);\n\t\t\t}\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tprivate _defaultValueSet: string[][] = [\n\t\t['true', 'false'],\n\t\t['True', 'False'],\n\t\t['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n\t\t['public', 'protected', 'private'],\n\t];\n\n\tprivate textReplace(value: string, up: boolean): string {\n\t\treturn this.valueSetsReplace(this._defaultValueSet, value, up);\n\t}\n\n\tprivate valueSetsReplace(valueSets: string[][], value: string, up: boolean): string {\n\t\tlet result: string = null;\n\t\tfor (let i = 0, len = valueSets.length; result === null && i < len; i++) {\n\t\t\tresult = this.valueSetReplace(valueSets[i], value, up);\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate valueSetReplace(valueSet: string[], value: string, up: boolean): string {\n\t\tlet idx = valueSet.indexOf(value);\n\t\tif (idx >= 0) {\n\t\t\tidx += up ? +1 : -1;\n\t\t\tif (idx < 0) {\n\t\t\t\tidx = valueSet.length - 1;\n\t\t\t} else {\n\t\t\t\tidx %= valueSet.length;\n\t\t\t}\n\t\t\treturn valueSet[idx];\n\t\t}\n\t\treturn null;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { Emitter } from 'vs/base/common/event';\nimport { KeyMod as ConstKeyMod, KeyChord } from 'vs/base/common/keyCodes';\nimport { Position } from 'vs/editor/common/core/position';\nimport { Range } from 'vs/editor/common/core/range';\nimport { Selection, SelectionDirection } from 'vs/editor/common/core/selection';\nimport { TPromise } from 'vs/base/common/winjs.base';\nimport { CancellationTokenSource } from 'vs/base/common/cancellation';\nimport { Token } from 'vs/editor/common/core/token';\nimport URI from 'vs/base/common/uri';\n\n// --------------------------------------------\n// This is repeated here so it can be exported\n// because TS inlines const enums\n// --------------------------------------------\nexport enum Severity {\n\tIgnore = 0,\n\tInfo = 1,\n\tWarning = 2,\n\tError = 3,\n}\n\nexport enum MarkerSeverity {\n\tHint = 1,\n\tInfo = 2,\n\tWarning = 4,\n\tError = 8,\n}\n\n// --------------------------------------------\n// This is repeated here so it can be exported\n// because TS inlines const enums\n// --------------------------------------------\nexport class KeyMod {\n\tpublic static readonly CtrlCmd: number = ConstKeyMod.CtrlCmd;\n\tpublic static readonly Shift: number = ConstKeyMod.Shift;\n\tpublic static readonly Alt: number = ConstKeyMod.Alt;\n\tpublic static readonly WinCtrl: number = ConstKeyMod.WinCtrl;\n\n\tpublic static chord(firstPart: number, secondPart: number): number {\n\t\treturn KeyChord(firstPart, secondPart);\n\t}\n}\n\n// --------------------------------------------\n// This is repeated here so it can be exported\n// because TS inlines const enums\n// --------------------------------------------\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 enum KeyCode {\n\t/**\n\t * Placed first to cover the 0 value of the enum.\n\t */\n\tUnknown = 0,\n\tBackspace = 1,\n\tTab = 2,\n\tEnter = 3,\n\tShift = 4,\n\tCtrl = 5,\n\tAlt = 6,\n\tPauseBreak = 7,\n\tCapsLock = 8,\n\tEscape = 9,\n\tSpace = 10,\n\tPageUp = 11,\n\tPageDown = 12,\n\tEnd = 13,\n\tHome = 14,\n\tLeftArrow = 15,\n\tUpArrow = 16,\n\tRightArrow = 17,\n\tDownArrow = 18,\n\tInsert = 19,\n\tDelete = 20,\n\tKEY_0 = 21,\n\tKEY_1 = 22,\n\tKEY_2 = 23,\n\tKEY_3 = 24,\n\tKEY_4 = 25,\n\tKEY_5 = 26,\n\tKEY_6 = 27,\n\tKEY_7 = 28,\n\tKEY_8 = 29,\n\tKEY_9 = 30,\n\tKEY_A = 31,\n\tKEY_B = 32,\n\tKEY_C = 33,\n\tKEY_D = 34,\n\tKEY_E = 35,\n\tKEY_F = 36,\n\tKEY_G = 37,\n\tKEY_H = 38,\n\tKEY_I = 39,\n\tKEY_J = 40,\n\tKEY_K = 41,\n\tKEY_L = 42,\n\tKEY_M = 43,\n\tKEY_N = 44,\n\tKEY_O = 45,\n\tKEY_P = 46,\n\tKEY_Q = 47,\n\tKEY_R = 48,\n\tKEY_S = 49,\n\tKEY_T = 50,\n\tKEY_U = 51,\n\tKEY_V = 52,\n\tKEY_W = 53,\n\tKEY_X = 54,\n\tKEY_Y = 55,\n\tKEY_Z = 56,\n\tMeta = 57,\n\tContextMenu = 58,\n\tF1 = 59,\n\tF2 = 60,\n\tF3 = 61,\n\tF4 = 62,\n\tF5 = 63,\n\tF6 = 64,\n\tF7 = 65,\n\tF8 = 66,\n\tF9 = 67,\n\tF10 = 68,\n\tF11 = 69,\n\tF12 = 70,\n\tF13 = 71,\n\tF14 = 72,\n\tF15 = 73,\n\tF16 = 74,\n\tF17 = 75,\n\tF18 = 76,\n\tF19 = 77,\n\tNumLock = 78,\n\tScrollLock = 79,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ';:' key\n\t */\n\tUS_SEMICOLON = 80,\n\t/**\n\t * For any country/region, the '+' key\n\t * For the US standard keyboard, the '=+' key\n\t */\n\tUS_EQUAL = 81,\n\t/**\n\t * For any country/region, the ',' key\n\t * For the US standard keyboard, the ',<' key\n\t */\n\tUS_COMMA = 82,\n\t/**\n\t * For any country/region, the '-' key\n\t * For the US standard keyboard, the '-_' key\n\t */\n\tUS_MINUS = 83,\n\t/**\n\t * For any country/region, the '.' key\n\t * For the US standard keyboard, the '.>' key\n\t */\n\tUS_DOT = 84,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '/?' key\n\t */\n\tUS_SLASH = 85,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '`~' key\n\t */\n\tUS_BACKTICK = 86,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '[{' key\n\t */\n\tUS_OPEN_SQUARE_BRACKET = 87,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the '\\|' key\n\t */\n\tUS_BACKSLASH = 88,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ']}' key\n\t */\n\tUS_CLOSE_SQUARE_BRACKET = 89,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t * For the US standard keyboard, the ''\"' key\n\t */\n\tUS_QUOTE = 90,\n\t/**\n\t * Used for miscellaneous characters; it can vary by keyboard.\n\t */\n\tOEM_8 = 91,\n\t/**\n\t * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n\t */\n\tOEM_102 = 92,\n\tNUMPAD_0 = 93,\n\tNUMPAD_1 = 94,\n\tNUMPAD_2 = 95,\n\tNUMPAD_3 = 96,\n\tNUMPAD_4 = 97,\n\tNUMPAD_5 = 98,\n\tNUMPAD_6 = 99,\n\tNUMPAD_7 = 100,\n\tNUMPAD_8 = 101,\n\tNUMPAD_9 = 102,\n\tNUMPAD_MULTIPLY = 103,\n\tNUMPAD_ADD = 104,\n\tNUMPAD_SEPARATOR = 105,\n\tNUMPAD_SUBTRACT = 106,\n\tNUMPAD_DECIMAL = 107,\n\tNUMPAD_DIVIDE = 108,\n\t/**\n\t * Cover all key codes when IME is processing input.\n\t */\n\tKEY_IN_COMPOSITION = 109,\n\tABNT_C1 = 110,\n\tABNT_C2 = 111,\n\t/**\n\t * Placed last to cover the length of the enum.\n\t * Please do not depend on this value!\n\t */\n\tMAX_VALUE\n}\n\nexport function createMonacoBaseAPI(): typeof monaco {\n\treturn {\n\t\teditor: undefined,\n\t\tlanguages: undefined,\n\t\tCancellationTokenSource: CancellationTokenSource,\n\t\tEmitter: Emitter,\n\t\tKeyCode: KeyCode,\n\t\tKeyMod: KeyMod,\n\t\tPosition: Position,\n\t\tRange: Range,\n\t\tSelection: Selection,\n\t\tSelectionDirection: SelectionDirection,\n\t\tSeverity: Severity,\n\t\tMarkerSeverity: MarkerSeverity,\n\t\tPromise: TPromise,\n\t\tUri: <any>URI,\n\t\tToken: Token\n\t};\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport { toUint32 } from 'vs/editor/common/core/uint';\n\nexport class PrefixSumIndexOfResult {\n\t_prefixSumIndexOfResultBrand: void;\n\n\tindex: number;\n\tremainder: number;\n\n\tconstructor(index: number, remainder: number) {\n\t\tthis.index = index;\n\t\tthis.remainder = remainder;\n\t}\n}\n\nexport class PrefixSumComputer {\n\n\t/**\n\t * values[i] is the value at index i\n\t */\n\tprivate values: Uint32Array;\n\n\t/**\n\t * prefixSum[i] = SUM(heights[j]), 0 <= j <= i\n\t */\n\tprivate prefixSum: Uint32Array;\n\n\t/**\n\t * prefixSum[i], 0 <= i <= prefixSumValidIndex can be trusted\n\t */\n\tprivate prefixSumValidIndex: Int32Array;\n\n\tconstructor(values: Uint32Array) {\n\t\tthis.values = values;\n\t\tthis.prefixSum = new Uint32Array(values.length);\n\t\tthis.prefixSumValidIndex = new Int32Array(1);\n\t\tthis.prefixSumValidIndex[0] = -1;\n\t}\n\n\tpublic getCount(): number {\n\t\treturn this.values.length;\n\t}\n\n\tpublic insertValues(insertIndex: number, insertValues: Uint32Array): boolean {\n\t\tinsertIndex = toUint32(insertIndex);\n\t\tconst oldValues = this.values;\n\t\tconst oldPrefixSum = this.prefixSum;\n\t\tconst insertValuesLen = insertValues.length;\n\n\t\tif (insertValuesLen === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.values = new Uint32Array(oldValues.length + insertValuesLen);\n\t\tthis.values.set(oldValues.subarray(0, insertIndex), 0);\n\t\tthis.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n\t\tthis.values.set(insertValues, insertIndex);\n\n\t\tif (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n\t\t\tthis.prefixSumValidIndex[0] = insertIndex - 1;\n\t\t}\n\n\t\tthis.prefixSum = new Uint32Array(this.values.length);\n\t\tif (this.prefixSumValidIndex[0] >= 0) {\n\t\t\tthis.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n\t\t}\n\t\treturn true;\n\t}\n\n\tpublic changeValue(index: number, value: number): boolean {\n\t\tindex = toUint32(index);\n\t\tvalue = toUint32(value);\n\n\t\tif (this.values[index] === value) {\n\t\t\treturn false;\n\t\t}\n\t\tthis.values[index] = value;\n\t\tif (index - 1 < this.prefixSumValidIndex[0]) {\n\t\t\tthis.prefixSumValidIndex[0] = index - 1;\n\t\t}\n\t\treturn true;\n\t}\n\n\tpublic removeValues(startIndex: number, cnt: number): boolean {\n\t\tstartIndex = toUint32(startIndex);\n\t\tcnt = toUint32(cnt);\n\n\t\tconst oldValues = this.values;\n\t\tconst oldPrefixSum = this.prefixSum;\n\n\t\tif (startIndex >= oldValues.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tlet maxCnt = oldValues.length - startIndex;\n\t\tif (cnt >= maxCnt) {\n\t\t\tcnt = maxCnt;\n\t\t}\n\n\t\tif (cnt === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tthis.values = new Uint32Array(oldValues.length - cnt);\n\t\tthis.values.set(oldValues.subarray(0, startIndex), 0);\n\t\tthis.values.set(oldValues.subarray(startIndex + cnt), startIndex);\n\n\t\tthis.prefixSum = new Uint32Array(this.values.length);\n\t\tif (startIndex - 1 < this.prefixSumValidIndex[0]) {\n\t\t\tthis.prefixSumValidIndex[0] = startIndex - 1;\n\t\t}\n\t\tif (this.prefixSumValidIndex[0] >= 0) {\n\t\t\tthis.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n\t\t}\n\t\treturn true;\n\t}\n\n\tpublic getTotalValue(): number {\n\t\tif (this.values.length === 0) {\n\t\t\treturn 0;\n\t\t}\n\t\treturn this._getAccumulatedValue(this.values.length - 1);\n\t}\n\n\tpublic getAccumulatedValue(index: number): number {\n\t\tif (index < 0) {\n\t\t\treturn 0;\n\t\t}\n\n\t\tindex = toUint32(index);\n\t\treturn this._getAccumulatedValue(index);\n\t}\n\n\tprivate _getAccumulatedValue(index: number): number {\n\t\tif (index <= this.prefixSumValidIndex[0]) {\n\t\t\treturn this.prefixSum[index];\n\t\t}\n\n\t\tlet startIndex = this.prefixSumValidIndex[0] + 1;\n\t\tif (startIndex === 0) {\n\t\t\tthis.prefixSum[0] = this.values[0];\n\t\t\tstartIndex++;\n\t\t}\n\n\t\tif (index >= this.values.length) {\n\t\t\tindex = this.values.length - 1;\n\t\t}\n\n\t\tfor (let i = startIndex; i <= index; i++) {\n\t\t\tthis.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n\t\t}\n\t\tthis.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n\t\treturn this.prefixSum[index];\n\t}\n\n\tpublic getIndexOf(accumulatedValue: number): PrefixSumIndexOfResult {\n\t\taccumulatedValue = Math.floor(accumulatedValue); //@perf\n\n\t\t// Compute all sums (to get a fully valid prefixSum)\n\t\tthis.getTotalValue();\n\n\t\tlet low = 0;\n\t\tlet high = this.values.length - 1;\n\t\tlet mid: number;\n\t\tlet midStop: number;\n\t\tlet midStart: number;\n\n\t\twhile (low <= high) {\n\t\t\tmid = low + ((high - low) / 2) | 0;\n\n\t\t\tmidStop = this.prefixSum[mid];\n\t\t\tmidStart = midStop - this.values[mid];\n\n\t\t\tif (accumulatedValue < midStart) {\n\t\t\t\thigh = mid - 1;\n\t\t\t} else if (accumulatedValue >= midStop) {\n\t\t\t\tlow = mid + 1;\n\t\t\t} else {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn new PrefixSumIndexOfResult(mid, accumulatedValue - midStart);\n\t}\n}\n\nexport class PrefixSumComputerWithCache {\n\n\tprivate readonly _actual: PrefixSumComputer;\n\tprivate _cacheAccumulatedValueStart: number = 0;\n\tprivate _cache: PrefixSumIndexOfResult[] = null;\n\n\tconstructor(values: Uint32Array) {\n\t\tthis._actual = new PrefixSumComputer(values);\n\t\tthis._bustCache();\n\t}\n\n\tprivate _bustCache(): void {\n\t\tthis._cacheAccumulatedValueStart = 0;\n\t\tthis._cache = null;\n\t}\n\n\tpublic insertValues(insertIndex: number, insertValues: Uint32Array): void {\n\t\tif (this._actual.insertValues(insertIndex, insertValues)) {\n\t\t\tthis._bustCache();\n\t\t}\n\t}\n\n\tpublic changeValue(index: number, value: number): void {\n\t\tif (this._actual.changeValue(index, value)) {\n\t\t\tthis._bustCache();\n\t\t}\n\t}\n\n\tpublic removeValues(startIndex: number, cnt: number): void {\n\t\tif (this._actual.removeValues(startIndex, cnt)) {\n\t\t\tthis._bustCache();\n\t\t}\n\t}\n\n\tpublic getTotalValue(): number {\n\t\treturn this._actual.getTotalValue();\n\t}\n\n\tpublic getAccumulatedValue(index: number): number {\n\t\treturn this._actual.getAccumulatedValue(index);\n\t}\n\n\tpublic getIndexOf(accumulatedValue: number): PrefixSumIndexOfResult {\n\t\taccumulatedValue = Math.floor(accumulatedValue); //@perf\n\n\t\tif (this._cache !== null) {\n\t\t\tlet cacheIndex = accumulatedValue - this._cacheAccumulatedValueStart;\n\t\t\tif (cacheIndex >= 0 && cacheIndex < this._cache.length) {\n\t\t\t\t// Cache hit!\n\t\t\t\treturn this._cache[cacheIndex];\n\t\t\t}\n\t\t}\n\n\t\t// Cache miss!\n\t\treturn this._actual.getIndexOf(accumulatedValue);\n\t}\n\n\t/**\n\t * Gives a hint that a lot of requests are about to come in for these accumulated values.\n\t */\n\tpublic warmUpCache(accumulatedValueStart: number, accumulatedValueEnd: number): void {\n\t\tlet newCache: PrefixSumIndexOfResult[] = [];\n\t\tfor (let accumulatedValue = accumulatedValueStart; accumulatedValue <= accumulatedValueEnd; accumulatedValue++) {\n\t\t\tnewCache[accumulatedValue - accumulatedValueStart] = this.getIndexOf(accumulatedValue);\n\t\t}\n\t\tthis._cache = newCache;\n\t\tthis._cacheAccumulatedValueStart = accumulatedValueStart;\n\t}\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n\nimport URI from 'vs/base/common/uri';\nimport { IRange } from 'vs/editor/common/core/range';\nimport { PrefixSumComputer } from 'vs/editor/common/viewModel/prefixSumComputer';\nimport { IModelContentChange } from 'vs/editor/common/model/textModelEvents';\nimport { Position } from 'vs/editor/common/core/position';\n\nexport interface IModelChangedEvent {\n\t/**\n\t * The actual changes.\n\t */\n\treadonly changes: IModelContentChange[];\n\t/**\n\t * The (new) end-of-line character.\n\t */\n\treadonly eol: string;\n\t/**\n\t * The new version id the model has transitioned to.\n\t */\n\treadonly versionId: number;\n}\n\nexport class MirrorTextModel {\n\n\tprotected _uri: URI;\n\tprotected _lines: string[];\n\tprotected _eol: string;\n\tprotected _versionId: number;\n\tprotected _lineStarts: PrefixSumComputer;\n\n\tconstructor(uri: URI, lines: string[], eol: string, versionId: number) {\n\t\tthis._uri = uri;\n\t\tthis._lines = lines;\n\t\tthis._eol = eol;\n\t\tthis._versionId = versionId;\n\t}\n\n\tdispose(): void {\n\t\tthis._lines.length = 0;\n\t}\n\n\tget version(): number {\n\t\treturn this._versionId;\n\t}\n\n\tgetText(): string {\n\t\treturn this._lines.join(this._eol);\n\t}\n\n\tonEvents(e: IModelChangedEvent): void {\n\t\tif (e.eol && e.eol !== this._eol) {\n\t\t\tthis._eol = e.eol;\n\t\t\tthis._lineStarts = null;\n\t\t}\n\n\t\t// Update my lines\n\t\tconst changes = e.changes;\n\t\tfor (let i = 0, len = changes.length; i < len; i++) {\n\t\t\tconst change = changes[i];\n\t\t\tthis._acceptDeleteRange(change.range);\n\t\t\tthis._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n\t\t}\n\n\t\tthis._versionId = e.versionId;\n\t}\n\n\tprotected _ensureLineStarts(): void {\n\t\tif (!this._lineStarts) {\n\t\t\tconst eolLength = this._eol.length;\n\t\t\tconst linesLength = this._lines.length;\n\t\t\tconst lineStartValues = new Uint32Array(linesLength);\n\t\t\tfor (let i = 0; i < linesLength; i++) {\n\t\t\t\tlineStartValues[i] = this._lines[i].length + eolLength;\n\t\t\t}\n\t\t\tthis._lineStarts = new PrefixSumComputer(lineStartValues);\n\t\t}\n\t}\n\n\t/**\n\t * All changes to a line's text go through this method\n\t */\n\tprivate _setLineText(lineIndex: number, newValue: string): void {\n\t\tthis._lines[lineIndex] = newValue;\n\t\tif (this._lineStarts) {\n\t\t\t// update prefix sum\n\t\t\tthis._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n\t\t}\n\t}\n\n\tprivate _acceptDeleteRange(range: IRange): void {\n\n\t\tif (range.startLineNumber === range.endLineNumber) {\n\t\t\tif (range.startColumn === range.endColumn) {\n\t\t\t\t// Nothing to delete\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// Delete text on the affected line\n\t\t\tthis._setLineText(range.startLineNumber - 1,\n\t\t\t\tthis._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n\t\t\t\t+ this._lines[range.startLineNumber - 1].substring(range.endColumn - 1)\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\n\t\t// Take remaining text on last line and append it to remaining text on first line\n\t\tthis._setLineText(range.startLineNumber - 1,\n\t\t\tthis._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n\t\t\t+ this._lines[range.endLineNumber - 1].substring(range.endColumn - 1)\n\t\t);\n\n\t\t// Delete middle lines\n\t\tthis._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n\t\tif (this._lineStarts) {\n\t\t\t// update prefix sum\n\t\t\tthis._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n\t\t}\n\t}\n\n\tprivate _acceptInsertText(position: Position, insertText: string): void {\n\t\tif (insertText.length === 0) {\n\t\t\t// Nothing to insert\n\t\t\treturn;\n\t\t}\n\t\tlet insertLines = insertText.split(/\\r\\n|\\r|\\n/);\n\t\tif (insertLines.length === 1) {\n\t\t\t// Inserting text on one line\n\t\t\tthis._setLineText(position.lineNumber - 1,\n\t\t\t\tthis._lines[position.lineNumber - 1].substring(0, position.column - 1)\n\t\t\t\t+ insertLines[0]\n\t\t\t\t+ this._lines[position.lineNumber - 1].substring(position.column - 1)\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\n\t\t// Append overflowing text from first line to the end of text to insert\n\t\tinsertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n\n\t\t// Delete overflowing text from first line and insert text on first line\n\t\tthis._setLineText(position.lineNumber - 1,\n\t\t\tthis._lines[position.lineNumber - 1].substring(0, position.column - 1)\n\t\t\t+ insertLines[0]\n\t\t);\n\n\t\t// Insert new lines & store lengths\n\t\tlet newLengths = new Uint32Array(insertLines.length - 1);\n\t\tfor (let i = 1; i < insertLines.length; i++) {\n\t\t\tthis._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n\t\t\tnewLengths[i - 1] = insertLines[i].length + this._eol.length;\n\t\t}\n\n\t\tif (this._lineStarts) {\n\t\t\t// update prefix sum\n\t\t\tthis._lineStarts.insertValues(position.lineNumber, newLengths);\n\t\t}\n\t}\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'use strict';\n\nimport URI from 'vs/base/common/uri';\nimport { TPromise } from 'vs/base/common/winjs.base';\nimport { IDisposable } from 'vs/base/common/lifecycle';\nimport { IRequestHandler } from 'vs/base/common/worker/simpleWorker';\nimport { Range, IRange } from 'vs/editor/common/core/range';\nimport { DiffComputer } from 'vs/editor/common/diff/diffComputer';\nimport { stringDiff } from 'vs/base/common/diff/diff';\nimport * as editorCommon from 'vs/editor/common/editorCommon';\nimport { Position, IPosition } from 'vs/editor/common/core/position';\nimport { MirrorTextModel as BaseMirrorModel, IModelChangedEvent } from 'vs/editor/common/model/mirrorTextModel';\nimport { IInplaceReplaceSupportResult, ILink, ISuggestResult, ISuggestion, TextEdit } from 'vs/editor/common/modes';\nimport { computeLinks } from 'vs/editor/common/modes/linkComputer';\nimport { BasicInplaceReplace } from 'vs/editor/common/modes/supports/inplaceReplaceSupport';\nimport { getWordAtText, ensureValidWordDefinition } from 'vs/editor/common/model/wordHelper';\nimport { createMonacoBaseAPI } from 'vs/editor/common/standalone/standaloneBase';\nimport { IWordAtPosition, EndOfLineSequence } from 'vs/editor/common/model';\nimport { globals } from 'vs/base/common/platform';\nimport { IIterator } from 'vs/base/common/iterator';\n\nexport interface IMirrorModel {\n\treadonly uri: URI;\n\treadonly version: number;\n\tgetValue(): string;\n}\n\nexport interface IWorkerContext {\n\t/**\n\t * Get all available mirror models in this worker.\n\t */\n\tgetMirrorModels(): IMirrorModel[];\n}\n\n/**\n * @internal\n */\nexport interface IRawModelData {\n\turl: string;\n\tversionId: number;\n\tlines: string[];\n\tEOL: string;\n}\n\n/**\n * @internal\n */\nexport interface ICommonModel {\n\turi: URI;\n\tversion: number;\n\teol: string;\n\tgetValue(): string;\n\n\tgetLinesContent(): string[];\n\tgetLineCount(): number;\n\tgetLineContent(lineNumber: number): string;\n\tcreateWordIterator(wordDefinition: RegExp): IIterator<string>;\n\tgetWordUntilPosition(position: IPosition, wordDefinition: RegExp): IWordAtPosition;\n\tgetValueInRange(range: IRange): string;\n\tgetWordAtPosition(position: IPosition, wordDefinition: RegExp): Range;\n\toffsetAt(position: IPosition): number;\n\tpositionAt(offset: number): IPosition;\n}\n\n/**\n * Range of a word inside a model.\n * @internal\n */\ninterface IWordRange {\n\t/**\n\t * The index where the word starts.\n\t */\n\treadonly start: number;\n\t/**\n\t * The index where the word ends.\n\t */\n\treadonly end: number;\n}\n\n/**\n * @internal\n */\nclass MirrorModel extends BaseMirrorModel implements ICommonModel {\n\n\tpublic get uri(): URI {\n\t\treturn this._uri;\n\t}\n\n\tpublic get version(): number {\n\t\treturn this._versionId;\n\t}\n\n\tpublic get eol(): string {\n\t\treturn this._eol;\n\t}\n\n\tpublic getValue(): string {\n\t\treturn this.getText();\n\t}\n\n\tpublic getLinesContent(): string[] {\n\t\treturn this._lines.slice(0);\n\t}\n\n\tpublic getLineCount(): number {\n\t\treturn this._lines.length;\n\t}\n\n\tpublic getLineContent(lineNumber: number): string {\n\t\treturn this._lines[lineNumber - 1];\n\t}\n\n\tpublic getWordAtPosition(position: IPosition, wordDefinition: RegExp): Range {\n\n\t\tlet wordAtText = getWordAtText(\n\t\t\tposition.column,\n\t\t\tensureValidWordDefinition(wordDefinition),\n\t\t\tthis._lines[position.lineNumber - 1],\n\t\t\t0\n\t\t);\n\n\t\tif (wordAtText) {\n\t\t\treturn new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tpublic getWordUntilPosition(position: IPosition, wordDefinition: RegExp): IWordAtPosition {\n\t\tconst wordAtPosition = this.getWordAtPosition(position, wordDefinition);\n\t\tif (!wordAtPosition) {\n\t\t\treturn {\n\t\t\t\tword: '',\n\t\t\t\tstartColumn: position.column,\n\t\t\t\tendColumn: position.column\n\t\t\t};\n\t\t}\n\t\treturn {\n\t\t\tword: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),\n\t\t\tstartColumn: wordAtPosition.startColumn,\n\t\t\tendColumn: position.column\n\t\t};\n\t}\n\n\tpublic createWordIterator(wordDefinition: RegExp): IIterator<string> {\n\t\tlet obj = {\n\t\t\tdone: false,\n\t\t\tvalue: ''\n\t\t};\n\t\tlet lineNumber = 0;\n\t\tlet lineText: string;\n\t\tlet wordRangesIdx = 0;\n\t\tlet wordRanges: IWordRange[] = [];\n\t\tlet next = () => {\n\n\t\t\tif (wordRangesIdx < wordRanges.length) {\n\t\t\t\tobj.done = false;\n\t\t\t\tobj.value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n\t\t\t\twordRangesIdx += 1;\n\n\t\t\t} else if (lineNumber >= this._lines.length) {\n\t\t\t\tobj.done = true;\n\t\t\t\tobj.value = undefined;\n\n\t\t\t} else {\n\t\t\t\tlineText = this._lines[lineNumber];\n\t\t\t\twordRanges = this._wordenize(lineText, wordDefinition);\n\t\t\t\twordRangesIdx = 0;\n\t\t\t\tlineNumber += 1;\n\t\t\t\treturn next();\n\t\t\t}\n\n\t\t\treturn obj;\n\t\t};\n\t\treturn { next };\n\t}\n\n\tprivate _wordenize(content: string, wordDefinition: RegExp): IWordRange[] {\n\t\tconst result: IWordRange[] = [];\n\t\tlet match: RegExpExecArray;\n\n\t\twordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n\n\t\twhile (match = wordDefinition.exec(content)) {\n\t\t\tif (match[0].length === 0) {\n\t\t\t\t// it did match the empty string\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tresult.push({ start: match.index, end: match.index + match[0].length });\n\t\t}\n\t\treturn result;\n\t}\n\n\tpublic getValueInRange(range: IRange): string {\n\t\trange = this._validateRange(range);\n\n\t\tif (range.startLineNumber === range.endLineNumber) {\n\t\t\treturn this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n\t\t}\n\n\t\tlet lineEnding = this._eol;\n\t\tlet startLineIndex = range.startLineNumber - 1;\n\t\tlet endLineIndex = range.endLineNumber - 1;\n\t\tlet resultLines: string[] = [];\n\n\t\tresultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n\t\tfor (let i = startLineIndex + 1; i < endLineIndex; i++) {\n\t\t\tresultLines.push(this._lines[i]);\n\t\t}\n\t\tresultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n\n\t\treturn resultLines.join(lineEnding);\n\t}\n\n\tpublic offsetAt(position: IPosition): number {\n\t\tposition = this._validatePosition(position);\n\t\tthis._ensureLineStarts();\n\t\treturn this._lineStarts.getAccumulatedValue(position.lineNumber - 2) + (position.column - 1);\n\t}\n\n\tpublic positionAt(offset: number): IPosition {\n\t\toffset = Math.floor(offset);\n\t\toffset = Math.max(0, offset);\n\n\t\tthis._ensureLineStarts();\n\t\tlet out = this._lineStarts.getIndexOf(offset);\n\t\tlet lineLength = this._lines[out.index].length;\n\n\t\t// Ensure we return a valid position\n\t\treturn {\n\t\t\tlineNumber: 1 + out.index,\n\t\t\tcolumn: 1 + Math.min(out.remainder, lineLength)\n\t\t};\n\t}\n\n\tprivate _validateRange(range: IRange): IRange {\n\n\t\tconst start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n\t\tconst end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n\n\t\tif (start.lineNumber !== range.startLineNumber\n\t\t\t|| start.column !== range.startColumn\n\t\t\t|| end.lineNumber !== range.endLineNumber\n\t\t\t|| end.column !== range.endColumn) {\n\n\t\t\treturn {\n\t\t\t\tstartLineNumber: start.lineNumber,\n\t\t\t\tstartColumn: start.column,\n\t\t\t\tendLineNumber: end.lineNumber,\n\t\t\t\tendColumn: end.column\n\t\t\t};\n\t\t}\n\n\t\treturn range;\n\t}\n\n\tprivate _validatePosition(position: IPosition): IPosition {\n\t\tif (!Position.isIPosition(position)) {\n\t\t\tthrow new Error('bad position');\n\t\t}\n\t\tlet { lineNumber, column } = position;\n\t\tlet hasChanged = false;\n\n\t\tif (lineNumber < 1) {\n\t\t\tlineNumber = 1;\n\t\t\tcolumn = 1;\n\t\t\thasChanged = true;\n\n\t\t} else if (lineNumber > this._lines.length) {\n\t\t\tlineNumber = this._lines.length;\n\t\t\tcolumn = this._lines[lineNumber - 1].length + 1;\n\t\t\thasChanged = true;\n\n\t\t} else {\n\t\t\tlet maxCharacter = this._lines[lineNumber - 1].length + 1;\n\t\t\tif (column < 1) {\n\t\t\t\tcolumn = 1;\n\t\t\t\thasChanged = true;\n\t\t\t}\n\t\t\telse if (column > maxCharacter) {\n\t\t\t\tcolumn = maxCharacter;\n\t\t\t\thasChanged = true;\n\t\t\t}\n\t\t}\n\n\t\tif (!hasChanged) {\n\t\t\treturn position;\n\t\t} else {\n\t\t\treturn { lineNumber, column };\n\t\t}\n\t}\n}\n\n/**\n * @internal\n */\nexport interface IForeignModuleFactory {\n\t(ctx: IWorkerContext, createData: any): any;\n}\n\ndeclare var require;\n\n/**\n * @internal\n */\nexport abstract class BaseEditorSimpleWorker {\n\tprivate _foreignModuleFactory: IForeignModuleFactory;\n\tprivate _foreignModule: any;\n\n\tconstructor(foreignModuleFactory: IForeignModuleFactory) {\n\t\tthis._foreignModuleFactory = foreignModuleFactory;\n\t\tthis._foreignModule = null;\n\t}\n\n\tprotected abstract _getModel(uri: string): ICommonModel;\n\tprotected abstract _getModels(): ICommonModel[];\n\n\t// ---- BEGIN diff --------------------------------------------------------------------------\n\n\tpublic computeDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.ILineChange[]> {\n\t\tlet original = this._getModel(originalUrl);\n\t\tlet modified = this._getModel(modifiedUrl);\n\t\tif (!original || !modified) {\n\t\t\treturn null;\n\t\t}\n\n\t\tlet originalLines = original.getLinesContent();\n\t\tlet modifiedLines = modified.getLinesContent();\n\t\tlet diffComputer = new DiffComputer(originalLines, modifiedLines, {\n\t\t\tshouldPostProcessCharChanges: true,\n\t\t\tshouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n\t\t\tshouldMakePrettyDiff: true\n\t\t});\n\t\treturn TPromise.as(diffComputer.computeDiff());\n\t}\n\n\tpublic computeDirtyDiff(originalUrl: string, modifiedUrl: string, ignoreTrimWhitespace: boolean): TPromise<editorCommon.IChange[]> {\n\t\tlet original = this._getModel(originalUrl);\n\t\tlet modified = this._getModel(modifiedUrl);\n\t\tif (!original || !modified) {\n\t\t\treturn null;\n\t\t}\n\n\t\tlet originalLines = original.getLinesContent();\n\t\tlet modifiedLines = modified.getLinesContent();\n\t\tlet diffComputer = new DiffComputer(originalLines, modifiedLines, {\n\t\t\tshouldPostProcessCharChanges: false,\n\t\t\tshouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n\t\t\tshouldMakePrettyDiff: true\n\t\t});\n\t\treturn TPromise.as(diffComputer.computeDiff());\n\t}\n\n\t// ---- END diff --------------------------------------------------------------------------\n\n\n\t// ---- BEGIN minimal edits ---------------------------------------------------------------\n\n\tprivate static readonly _diffLimit = 10000;\n\n\tpublic computeMoreMinimalEdits(modelUrl: string, edits: TextEdit[]): TPromise<TextEdit[]> {\n\t\tconst model = this._getModel(modelUrl);\n\t\tif (!model) {\n\t\t\treturn TPromise.as(edits);\n\t\t}\n\n\t\tconst result: TextEdit[] = [];\n\t\tlet lastEol: EndOfLineSequence;\n\n\t\tfor (let { range, text, eol } of edits) {\n\n\t\t\tif (typeof eol === 'number') {\n\t\t\t\tlastEol = eol;\n\t\t\t}\n\n\t\t\tif (!range) {\n\t\t\t\t// eol-change only\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst original = model.getValueInRange(range);\n\t\t\ttext = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n\n\t\t\tif (original === text) {\n\t\t\t\t// noop\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// make sure diff won't take too long\n\t\t\tif (Math.max(text.length, original.length) > BaseEditorSimpleWorker._diffLimit) {\n\t\t\t\tresult.push({ range, text });\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// compute diff between original and edit.text\n\t\t\tconst changes = stringDiff(original, text, false);\n\t\t\tconst editOffset = model.offsetAt(Range.lift(range).getStartPosition());\n\n\t\t\tfor (const change of changes) {\n\t\t\t\tconst start = model.positionAt(editOffset + change.originalStart);\n\t\t\t\tconst end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n\t\t\t\tconst newEdit: TextEdit = {\n\t\t\t\t\ttext: text.substr(change.modifiedStart, change.modifiedLength),\n\t\t\t\t\trange: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n\t\t\t\t};\n\n\t\t\t\tif (model.getValueInRange(newEdit.range) !== newEdit.text) {\n\t\t\t\t\tresult.push(newEdit);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (typeof lastEol === 'number') {\n\t\t\tresult.push({ eol: lastEol, text: undefined, range: undefined });\n\t\t}\n\n\t\treturn TPromise.as(result);\n\t}\n\n\t// ---- END minimal edits ---------------------------------------------------------------\n\n\tpublic computeLinks(modelUrl: string): TPromise<ILink[]> {\n\t\tlet model = this._getModel(modelUrl);\n\t\tif (!model) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn TPromise.as(computeLinks(model));\n\t}\n\n\t// ---- BEGIN suggest --------------------------------------------------------------------------\n\n\tprivate static readonly _suggestionsLimit = 10000;\n\n\tpublic textualSuggest(modelUrl: string, position: IPosition, wordDef: string, wordDefFlags: string): TPromise<ISuggestResult> {\n\t\tconst model = this._getModel(modelUrl);\n\t\tif (model) {\n\t\t\tconst suggestions: ISuggestion[] = [];\n\t\t\tconst wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n\t\t\tconst currentWord = model.getWordUntilPosition(position, wordDefRegExp).word;\n\n\t\t\tconst seen: Record<string, boolean> = Object.create(null);\n\t\t\tseen[currentWord] = true;\n\n\t\t\tfor (\n\t\t\t\tlet iter = model.createWordIterator(wordDefRegExp), e = iter.next();\n\t\t\t\t!e.done && suggestions.length <= BaseEditorSimpleWorker._suggestionsLimit;\n\t\t\t\te = iter.next()\n\t\t\t) {\n\t\t\t\tconst word = e.value;\n\t\t\t\tif (seen[word]) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tseen[word] = true;\n\t\t\t\tif (!isNaN(Number(word))) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tsuggestions.push({\n\t\t\t\t\ttype: 'text',\n\t\t\t\t\tlabel: word,\n\t\t\t\t\tinsertText: word,\n\t\t\t\t\tnoAutoAccept: true,\n\t\t\t\t\toverwriteBefore: currentWord.length\n\t\t\t\t});\n\t\t\t}\n\n\t\t\treturn TPromise.as({ suggestions });\n\t\t}\n\t\treturn undefined;\n\t}\n\n\n\t// ---- END suggest --------------------------------------------------------------------------\n\n\tpublic navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): TPromise<IInplaceReplaceSupportResult> {\n\t\tlet model = this._getModel(modelUrl);\n\t\tif (!model) {\n\t\t\treturn null;\n\t\t}\n\n\t\tlet wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n\n\t\tif (range.startColumn === range.endColumn) {\n\t\t\trange = {\n\t\t\t\tstartLineNumber: range.startLineNumber,\n\t\t\t\tstartColumn: range.startColumn,\n\t\t\t\tendLineNumber: range.endLineNumber,\n\t\t\t\tendColumn: range.endColumn + 1\n\t\t\t};\n\t\t}\n\n\t\tlet selectionText = model.getValueInRange(range);\n\n\t\tlet wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n\t\tlet word: string = null;\n\t\tif (wordRange !== null) {\n\t\t\tword = model.getValueInRange(wordRange);\n\t\t}\n\n\t\tlet result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n\t\treturn TPromise.as(result);\n\t}\n\n\t// ---- BEGIN foreign module support --------------------------------------------------------------------------\n\n\tpublic loadForeignModule(moduleId: string, createData: any): TPromise<string[]> {\n\t\tlet ctx: IWorkerContext = {\n\t\t\tgetMirrorModels: (): IMirrorModel[] => {\n\t\t\t\treturn this._getModels();\n\t\t\t}\n\t\t};\n\n\t\tif (this._foreignModuleFactory) {\n\t\t\tthis._foreignModule = this._foreignModuleFactory(ctx, createData);\n\t\t\t// static foreing module\n\t\t\tlet methods: string[] = [];\n\t\t\tfor (let prop in this._foreignModule) {\n\t\t\t\tif (typeof this._foreignModule[prop] === 'function') {\n\t\t\t\t\tmethods.push(prop);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn TPromise.as(methods);\n\t\t}\n\t\treturn new TPromise<any>((c, e) => {\n\t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n\t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n\n\t\t\t\tlet methods: string[] = [];\n\t\t\t\tfor (let prop in this._foreignModule) {\n\t\t\t\t\tif (typeof this._foreignModule[prop] === 'function') {\n\t\t\t\t\t\tmethods.push(prop);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tc(methods);\n\n\t\t\t}, e);\n\t\t});\n\t}\n\n\t// foreign method request\n\tpublic fmr(method: string, args: any[]): TPromise<any> {\n\t\tif (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\n\t\t\treturn TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));\n\t\t}\n\n\t\ttry {\n\t\t\treturn TPromise.as(this._foreignModule[method].apply(this._foreignModule, args));\n\t\t} catch (e) {\n\t\t\treturn TPromise.wrapError(e);\n\t\t}\n\t}\n\n\t// ---- END foreign module support --------------------------------------------------------------------------\n}\n\n/**\n * @internal\n */\nexport class EditorSimpleWorkerImpl extends BaseEditorSimpleWorker implements IRequestHandler, IDisposable {\n\t_requestHandlerBrand: any;\n\n\tprivate _models: { [uri: string]: MirrorModel; };\n\n\tconstructor(foreignModuleFactory: IForeignModuleFactory) {\n\t\tsuper(foreignModuleFactory);\n\t\tthis._models = Object.create(null);\n\t}\n\n\tpublic dispose(): void {\n\t\tthis._models = Object.create(null);\n\t}\n\n\tprotected _getModel(uri: string): ICommonModel {\n\t\treturn this._models[uri];\n\t}\n\n\tprotected _getModels(): ICommonModel[] {\n\t\tlet all: MirrorModel[] = [];\n\t\tObject.keys(this._models).forEach((key) => all.push(this._models[key]));\n\t\treturn all;\n\t}\n\n\tpublic acceptNewModel(data: IRawModelData): void {\n\t\tthis._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\n\t}\n\n\tpublic acceptModelChanged(strURL: string, e: IModelChangedEvent): void {\n\t\tif (!this._models[strURL]) {\n\t\t\treturn;\n\t\t}\n\t\tlet model = this._models[strURL];\n\t\tmodel.onEvents(e);\n\t}\n\n\tpublic acceptRemovedModel(strURL: string): void {\n\t\tif (!this._models[strURL]) {\n\t\t\treturn;\n\t\t}\n\t\tdelete this._models[strURL];\n\t}\n}\n\n/**\n * Called on the worker side\n * @internal\n */\nexport function create(): IRequestHandler {\n\treturn new EditorSimpleWorkerImpl(null);\n}\n\n// This is only available in a Web Worker\ndeclare function importScripts(...urls: string[]): void;\n\nif (typeof importScripts === 'function') {\n\t// Running in a web worker\n\tglobals.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 *--------------------------------------------------------------------------------------------*/\n\n(function () {\n\t'use strict';\n\n\tlet MonacoEnvironment = (<any>self).MonacoEnvironment;\n\tlet monacoBaseUrl = MonacoEnvironment && MonacoEnvironment.baseUrl ? MonacoEnvironment.baseUrl : '../../../';\n\n\tif (typeof (<any>self).define !== 'function' || !(<any>self).define.amd) {\n\t\timportScripts(monacoBaseUrl + 'vs/loader.js');\n\t}\n\n\trequire.config({\n\t\tbaseUrl: monacoBaseUrl,\n\t\tcatchError: true\n\t});\n\n\tlet loadCode = function (moduleId: string) {\n\t\trequire([moduleId], function (ws) {\n\t\t\tsetTimeout(function () {\n\t\t\t\tlet messageHandler = ws.create((msg: any) => {\n\t\t\t\t\t(<any>self).postMessage(msg);\n\t\t\t\t}, null);\n\n\t\t\t\tself.onmessage = (e) => messageHandler.onmessage(e.data);\n\t\t\t\twhile (beforeReadyMessages.length > 0) {\n\t\t\t\t\tself.onmessage(beforeReadyMessages.shift());\n\t\t\t\t}\n\t\t\t}, 0);\n\t\t});\n\t};\n\n\tlet isFirstMessage = true;\n\tlet beforeReadyMessages: MessageEvent[] = [];\n\tself.onmessage = (message) => {\n\t\tif (!isFirstMessage) {\n\t\t\tbeforeReadyMessages.push(message);\n\t\t\treturn;\n\t\t}\n\n\t\tisFirstMessage = false;\n\t\tloadCode(message.data);\n\t};\n})();\n"]} |