@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/debug/browser/debugEditorContribution.js

@@ -0,0 +1,740 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { addDisposableListener, isKeyboardEvent } from 'vscode/vscode/vs/base/browser/dom';
+import { DomEmitter } from 'vscode/vscode/vs/base/browser/event';
+import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
+import { distinct } from 'vscode/vscode/vs/base/common/arrays';
+import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { memoize } from 'vscode/vscode/vs/base/common/decorators';
+import { illegalArgument, onUnexpectedExternalError } from 'vscode/vscode/vs/base/common/errors';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { visit } from 'vscode/vscode/vs/base/common/json';
+import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
+import { MutableDisposable, DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { clamp } from 'vscode/vscode/vs/base/common/numbers';
+import { basename } from 'vscode/vscode/vs/base/common/path';
+import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
+import { format, noBreakWhitespace } from 'vscode/vscode/vs/base/common/strings';
+import { assertType, isDefined } from 'vscode/vscode/vs/base/common/types';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { CoreEditingCommands } from 'vscode/vscode/vs/editor/browser/coreCommands';
+import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
+import { Position } from 'vscode/vscode/vs/editor/common/core/position';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { DEFAULT_WORD_REGEXP } from 'vscode/vscode/vs/editor/common/core/wordHelper';
+import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
+import { ILanguageFeatureDebounceService } from 'vscode/vscode/vs/editor/common/services/languageFeatureDebounce';
+import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CommandsRegistry, ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { registerColor } from 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { DebugHoverWidget } from './debugHover.js';
+import { ExceptionWidget } from './exceptionWidget.js';
+import { CONTEXT_EXCEPTION_WIDGET_VISIBLE, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Expression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+
+const MAX_NUM_INLINE_VALUES = 100;
+const MAX_INLINE_DECORATOR_LENGTH = 150;
+const MAX_TOKENIZATION_LINE_LEN = 500;
+const DEAFULT_INLINE_DEBOUNCE_DELAY = 200;
+registerColor('editor.inlineValuesForeground', {
+    dark: '#ffffff80',
+    light: '#00000080',
+    hcDark: '#ffffff80',
+    hcLight: '#00000080'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/debugEditorContribution',
+    'editor.inlineValuesForeground',
+    "Color for the debug inline value text."
+)));
+registerColor('editor.inlineValuesBackground', {
+    dark: '#ffc80033',
+    light: '#ffc80033',
+    hcDark: '#ffc80033',
+    hcLight: '#ffc80033'
+}, ( localizeWithPath(
+    'vs/workbench/contrib/debug/browser/debugEditorContribution',
+    'editor.inlineValuesBackground',
+    "Color for the debug inline value background."
+)));
+class InlineSegment {
+    constructor(column, text) {
+        this.column = column;
+        this.text = text;
+    }
+}
+function createInlineValueDecoration(lineNumber, contentText, column = 1073741824 ) {
+    if (contentText.length > MAX_INLINE_DECORATOR_LENGTH) {
+        contentText = contentText.substring(0, MAX_INLINE_DECORATOR_LENGTH) + '...';
+    }
+    return [
+        {
+            range: {
+                startLineNumber: lineNumber,
+                endLineNumber: lineNumber,
+                startColumn: column,
+                endColumn: column
+            },
+            options: {
+                description: 'debug-inline-value-decoration-spacer',
+                after: {
+                    content: noBreakWhitespace,
+                    cursorStops: InjectedTextCursorStops.None
+                },
+                showIfCollapsed: true,
+            }
+        },
+        {
+            range: {
+                startLineNumber: lineNumber,
+                endLineNumber: lineNumber,
+                startColumn: column,
+                endColumn: column
+            },
+            options: {
+                description: 'debug-inline-value-decoration',
+                after: {
+                    content: replaceWsWithNoBreakWs(contentText),
+                    inlineClassName: 'debug-inline-value',
+                    inlineClassNameAffectsLetterSpacing: true,
+                    cursorStops: InjectedTextCursorStops.None
+                },
+                showIfCollapsed: true,
+            }
+        },
+    ];
+}
+function replaceWsWithNoBreakWs(str) {
+    return str.replace(/[ \t]/g, noBreakWhitespace);
+}
+function createInlineValueDecorationsInsideRange(expressions, ranges, model, wordToLineNumbersMap) {
+    const nameValueMap = ( new Map());
+    for (const expr of expressions) {
+        nameValueMap.set(expr.name, expr.value);
+        if (nameValueMap.size >= MAX_NUM_INLINE_VALUES) {
+            break;
+        }
+    }
+    const lineToNamesMap = ( new Map());
+    nameValueMap.forEach((_value, name) => {
+        const lineNumbers = wordToLineNumbersMap.get(name);
+        if (lineNumbers) {
+            for (const lineNumber of lineNumbers) {
+                if (( ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber))) {
+                    if (!( lineToNamesMap.has(lineNumber))) {
+                        lineToNamesMap.set(lineNumber, []);
+                    }
+                    if (lineToNamesMap.get(lineNumber).indexOf(name) === -1) {
+                        lineToNamesMap.get(lineNumber).push(name);
+                    }
+                }
+            }
+        }
+    });
+    const decorations = [];
+    lineToNamesMap.forEach((names, line) => {
+        const contentText = ( names.sort((first, second) => {
+            const content = model.getLineContent(line);
+            return content.indexOf(first) - content.indexOf(second);
+        }).map(name => `${name} = ${nameValueMap.get(name)}`)).join(', ');
+        decorations.push(...createInlineValueDecoration(line, contentText));
+    });
+    return decorations;
+}
+function getWordToLineNumbersMap(model, lineNumber, result) {
+    const lineLength = model.getLineLength(lineNumber);
+    if (lineLength > MAX_TOKENIZATION_LINE_LEN) {
+        return;
+    }
+    const lineContent = model.getLineContent(lineNumber);
+    model.tokenization.forceTokenization(lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(lineNumber);
+    for (let tokenIndex = 0, tokenCount = lineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {
+        const tokenType = lineTokens.getStandardTokenType(tokenIndex);
+        if (tokenType === 0 ) {
+            DEFAULT_WORD_REGEXP.lastIndex = 0;
+            const tokenStartOffset = lineTokens.getStartOffset(tokenIndex);
+            const tokenEndOffset = lineTokens.getEndOffset(tokenIndex);
+            const tokenStr = lineContent.substring(tokenStartOffset, tokenEndOffset);
+            const wordMatch = DEFAULT_WORD_REGEXP.exec(tokenStr);
+            if (wordMatch) {
+                const word = wordMatch[0];
+                if (!( result.has(word))) {
+                    result.set(word, []);
+                }
+                result.get(word).push(lineNumber);
+            }
+        }
+    }
+}
+let DebugEditorContribution = class DebugEditorContribution {
+    constructor(editor, debugService, instantiationService, commandService, configurationService, hostService, uriIdentityService, contextKeyService, languageFeaturesService, featureDebounceService) {
+        this.editor = editor;
+        this.debugService = debugService;
+        this.instantiationService = instantiationService;
+        this.commandService = commandService;
+        this.configurationService = configurationService;
+        this.hostService = hostService;
+        this.uriIdentityService = uriIdentityService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.hoverPosition = null;
+        this.mouseDown = false;
+        this.gutterIsHovered = false;
+        this.altListener = ( new MutableDisposable());
+        this.altPressed = false;
+        this.oldDecorations = this.editor.createDecorationsCollection();
+        this.displayedStore = ( new DisposableStore());
+        this.defaultHoverLockout = ( new MutableDisposable());
+        this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
+        this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
+        this.toDispose = [this.defaultHoverLockout, this.altListener, this.displayedStore];
+        this.registerListeners();
+        this.exceptionWidgetVisible = CONTEXT_EXCEPTION_WIDGET_VISIBLE.bindTo(contextKeyService);
+        this.toggleExceptionWidget();
+    }
+    registerListeners() {
+        this.toDispose.push(this.debugService.getViewModel().onDidFocusStackFrame(e => this.onFocusStackFrame(e.stackFrame)));
+        this.toDispose.push(this.editor.onMouseDown((e) => this.onEditorMouseDown(e)));
+        this.toDispose.push(this.editor.onMouseUp(() => this.mouseDown = false));
+        this.toDispose.push(this.editor.onMouseMove((e) => this.onEditorMouseMove(e)));
+        this.toDispose.push(this.editor.onMouseLeave((e) => {
+            const hoverDomNode = this.hoverWidget.getDomNode();
+            if (!hoverDomNode) {
+                return;
+            }
+            const rect = hoverDomNode.getBoundingClientRect();
+            if (e.event.posx < rect.left || e.event.posx > rect.right || e.event.posy < rect.top || e.event.posy > rect.bottom) {
+                this.hideHoverWidget();
+            }
+        }));
+        this.toDispose.push(this.editor.onKeyDown((e) => this.onKeyDown(e)));
+        this.toDispose.push(this.editor.onDidChangeModelContent(() => {
+            this._wordToLineNumbersMap = undefined;
+            this.updateInlineValuesScheduler.schedule();
+        }));
+        this.toDispose.push(this.debugService.getViewModel().onWillUpdateViews(() => this.updateInlineValuesScheduler.schedule()));
+        this.toDispose.push(this.debugService.getViewModel().onDidEvaluateLazyExpression(() => this.updateInlineValuesScheduler.schedule()));
+        this.toDispose.push(this.editor.onDidChangeModel(async () => {
+            this.addDocumentListeners();
+            this.toggleExceptionWidget();
+            this.hideHoverWidget();
+            this._wordToLineNumbersMap = undefined;
+            const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+            await this.updateInlineValueDecorations(stackFrame);
+        }));
+        this.toDispose.push(this.editor.onDidScrollChange(() => {
+            this.hideHoverWidget();
+            const model = this.editor.getModel();
+            if (model && ( this.languageFeaturesService.inlineValuesProvider.has(model))) {
+                this.updateInlineValuesScheduler.schedule();
+            }
+        }));
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('editor.hover')) {
+                this.updateHoverConfiguration();
+            }
+        }));
+        this.toDispose.push(this.debugService.onDidChangeState((state) => {
+            if (state !== 2 ) {
+                this.toggleExceptionWidget();
+            }
+        }));
+        this.updateHoverConfiguration();
+    }
+    updateHoverConfiguration() {
+        const model = this.editor.getModel();
+        if (model) {
+            this.editorHoverOptions = this.configurationService.getValue('editor.hover', {
+                resource: model.uri,
+                overrideIdentifier: model.getLanguageId()
+            });
+        }
+    }
+    addDocumentListeners() {
+        const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+        const model = this.editor.getModel();
+        if (model) {
+            this.applyDocumentListeners(model, stackFrame);
+        }
+    }
+    applyDocumentListeners(model, stackFrame) {
+        if (!stackFrame || !this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) {
+            this.altListener.clear();
+            return;
+        }
+        const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
+        this.altListener.value = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
+            const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
+            if (standardKeyboardEvent.keyCode === 6 ) {
+                this.altPressed = true;
+                const debugHoverWasVisible = this.hoverWidget.isVisible();
+                this.hoverWidget.hide();
+                this.defaultHoverLockout.clear();
+                if (debugHoverWasVisible && this.hoverPosition) {
+                    this.showEditorHover(this.hoverPosition, false);
+                }
+                const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
+                const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
+                    let standardKeyboardEvent = undefined;
+                    if (isKeyboardEvent(keyupEvent)) {
+                        standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
+                    }
+                    if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
+                        this.altPressed = false;
+                        this.preventDefaultEditorHover();
+                        listener.dispose();
+                        onKeyUp.dispose();
+                    }
+                });
+            }
+        });
+    }
+    async showHover(position, focus) {
+        this.preventDefaultEditorHover();
+        const sf = this.debugService.getViewModel().focusedStackFrame;
+        const model = this.editor.getModel();
+        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
+            const result = await this.hoverWidget.showAt(position, focus);
+            if (result === 1 ) {
+                this.showEditorHover(position, focus);
+            }
+        }
+        else {
+            this.showEditorHover(position, focus);
+        }
+    }
+    preventDefaultEditorHover() {
+        if (this.defaultHoverLockout.value || this.editorHoverOptions?.enabled === false) {
+            return;
+        }
+        const hoverController = this.editor.getContribution(HoverController.ID);
+        hoverController?.hideContentHover();
+        this.editor.updateOptions({ hover: { enabled: false } });
+        this.defaultHoverLockout.value = {
+            dispose: () => {
+                this.editor.updateOptions({
+                    hover: { enabled: this.editorHoverOptions?.enabled ?? true }
+                });
+            }
+        };
+    }
+    showEditorHover(position, focus) {
+        const hoverController = this.editor.getContribution(HoverController.ID);
+        const range = ( new Range(position.lineNumber, position.column, position.lineNumber, position.column));
+        this.defaultHoverLockout.clear();
+        hoverController?.showContentHover(range, 1 , 0 , focus);
+    }
+    async onFocusStackFrame(sf) {
+        const model = this.editor.getModel();
+        if (model) {
+            this.applyDocumentListeners(model, sf);
+            if (sf && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
+                await this.toggleExceptionWidget();
+            }
+            else {
+                this.hideHoverWidget();
+            }
+        }
+        await this.updateInlineValueDecorations(sf);
+    }
+    get hoverDelay() {
+        const baseDelay = this.editorHoverOptions?.delay || 0;
+        const delayFactor = clamp(2 - (baseDelay - 300) / 600, 1, 2);
+        return baseDelay * delayFactor;
+    }
+    get showHoverScheduler() {
+        const scheduler = ( new RunOnceScheduler(() => {
+            if (this.hoverPosition && !this.altPressed) {
+                this.showHover(this.hoverPosition, false);
+            }
+        }, this.hoverDelay));
+        this.toDispose.push(scheduler);
+        return scheduler;
+    }
+    hideHoverWidget() {
+        if (this.hoverWidget.willBeVisible()) {
+            this.hoverWidget.hide();
+        }
+        this.showHoverScheduler.cancel();
+        this.defaultHoverLockout.clear();
+    }
+    onEditorMouseDown(mouseEvent) {
+        this.mouseDown = true;
+        if (mouseEvent.target.type === 9  && mouseEvent.target.detail === DebugHoverWidget.ID) {
+            return;
+        }
+        this.hideHoverWidget();
+    }
+    onEditorMouseMove(mouseEvent) {
+        if (this.debugService.state !== 2 ) {
+            return;
+        }
+        const target = mouseEvent.target;
+        const stopKey = isMacintosh ? 'metaKey' : 'ctrlKey';
+        if (!this.altPressed) {
+            if (target.type === 2 ) {
+                this.defaultHoverLockout.clear();
+                this.gutterIsHovered = true;
+            }
+            else if (this.gutterIsHovered) {
+                this.gutterIsHovered = false;
+                this.updateHoverConfiguration();
+            }
+        }
+        if (target.type === 9  && target.detail === DebugHoverWidget.ID && !mouseEvent.event[stopKey]) {
+            const sticky = this.editorHoverOptions?.sticky ?? true;
+            if (sticky || this.hoverWidget.isShowingComplexValue) {
+                return;
+            }
+        }
+        if (target.type === 6 ) {
+            if (target.position && !Position.equals(target.position, this.hoverPosition)) {
+                this.hoverPosition = target.position;
+                this.preventDefaultEditorHover();
+                this.showHoverScheduler.schedule(this.hoverDelay);
+            }
+        }
+        else if (!this.mouseDown) {
+            this.hideHoverWidget();
+        }
+    }
+    onKeyDown(e) {
+        const stopKey = isMacintosh ? 57  : 5 ;
+        if (e.keyCode !== stopKey && e.keyCode !== 6 ) {
+            this.hideHoverWidget();
+        }
+    }
+    async toggleExceptionWidget() {
+        const model = this.editor.getModel();
+        const focusedSf = this.debugService.getViewModel().focusedStackFrame;
+        const callStack = focusedSf ? focusedSf.thread.getCallStack() : null;
+        if (!model || !focusedSf || !callStack || callStack.length === 0) {
+            this.closeExceptionWidget();
+            return;
+        }
+        const exceptionSf = callStack.find(sf => !!(sf && sf.source && sf.source.available && sf.source.presentationHint !== 'deemphasize'));
+        if (!exceptionSf || exceptionSf !== focusedSf) {
+            this.closeExceptionWidget();
+            return;
+        }
+        const sameUri = this.uriIdentityService.extUri.isEqual(exceptionSf.source.uri, model.uri);
+        if (this.exceptionWidget && !sameUri) {
+            this.closeExceptionWidget();
+        }
+        else if (sameUri) {
+            const exceptionInfo = await focusedSf.thread.exceptionInfo;
+            if (exceptionInfo) {
+                this.showExceptionWidget(exceptionInfo, this.debugService.getViewModel().focusedSession, exceptionSf.range.startLineNumber, exceptionSf.range.startColumn);
+            }
+        }
+    }
+    showExceptionWidget(exceptionInfo, debugSession, lineNumber, column) {
+        if (this.exceptionWidget) {
+            this.exceptionWidget.dispose();
+        }
+        this.exceptionWidget = this.instantiationService.createInstance(ExceptionWidget, this.editor, exceptionInfo, debugSession);
+        this.exceptionWidget.show({ lineNumber, column }, 0);
+        this.exceptionWidget.focus();
+        this.editor.revealRangeInCenter({
+            startLineNumber: lineNumber,
+            startColumn: column,
+            endLineNumber: lineNumber,
+            endColumn: column,
+        });
+        this.exceptionWidgetVisible.set(true);
+    }
+    closeExceptionWidget() {
+        if (this.exceptionWidget) {
+            const shouldFocusEditor = this.exceptionWidget.hasFocus();
+            this.exceptionWidget.dispose();
+            this.exceptionWidget = undefined;
+            this.exceptionWidgetVisible.set(false);
+            if (shouldFocusEditor) {
+                this.editor.focus();
+            }
+        }
+    }
+    async addLaunchConfiguration() {
+        const model = this.editor.getModel();
+        if (!model) {
+            return;
+        }
+        let configurationsArrayPosition;
+        let lastProperty;
+        const getConfigurationPosition = () => {
+            let depthInArray = 0;
+            visit(model.getValue(), {
+                onObjectProperty: (property) => {
+                    lastProperty = property;
+                },
+                onArrayBegin: (offset) => {
+                    if (lastProperty === 'configurations' && depthInArray === 0) {
+                        configurationsArrayPosition = model.getPositionAt(offset + 1);
+                    }
+                    depthInArray++;
+                },
+                onArrayEnd: () => {
+                    depthInArray--;
+                }
+            });
+        };
+        getConfigurationPosition();
+        if (!configurationsArrayPosition) {
+            const { tabSize, insertSpaces } = model.getOptions();
+            const eol = model.getEOL();
+            const edit = (basename(model.uri.fsPath) === 'launch.json') ?
+                setProperty(model.getValue(), ['configurations'], [], { tabSize, insertSpaces, eol })[0] :
+                setProperty(model.getValue(), ['launch'], { 'configurations': [] }, { tabSize, insertSpaces, eol })[0];
+            const startPosition = model.getPositionAt(edit.offset);
+            const lineNumber = startPosition.lineNumber;
+            const range = ( new Range(
+                lineNumber,
+                startPosition.column,
+                lineNumber,
+                model.getLineMaxColumn(lineNumber)
+            ));
+            model.pushEditOperations(null, [EditOperation.replace(range, edit.content)], () => null);
+            getConfigurationPosition();
+        }
+        if (!configurationsArrayPosition) {
+            return;
+        }
+        this.editor.focus();
+        const insertLine = (position) => {
+            if (model.getLineLastNonWhitespaceColumn(position.lineNumber) > position.column) {
+                this.editor.setPosition(position);
+                CoreEditingCommands.LineBreakInsert.runEditorCommand(null, this.editor, null);
+            }
+            this.editor.setPosition(position);
+            return this.commandService.executeCommand('editor.action.insertLineAfter');
+        };
+        await insertLine(configurationsArrayPosition);
+        await this.commandService.executeCommand('editor.action.triggerSuggest');
+    }
+    get removeInlineValuesScheduler() {
+        return ( new RunOnceScheduler(() => {
+            this.displayedStore.clear();
+        }, 100));
+    }
+    get updateInlineValuesScheduler() {
+        const model = this.editor.getModel();
+        return ( new RunOnceScheduler(
+            async () => await this.updateInlineValueDecorations(this.debugService.getViewModel().focusedStackFrame),
+            model ? this.debounceInfo.get(model) : DEAFULT_INLINE_DEBOUNCE_DELAY
+        ));
+    }
+    async updateInlineValueDecorations(stackFrame) {
+        const var_value_format = '{0} = {1}';
+        const separator = ', ';
+        const model = this.editor.getModel();
+        const inlineValuesSetting = this.configurationService.getValue('debug').inlineValues;
+        const inlineValuesTurnedOn = inlineValuesSetting === true || inlineValuesSetting === 'on' || (inlineValuesSetting === 'auto' && model && ( this.languageFeaturesService.inlineValuesProvider.has(model)));
+        if (!inlineValuesTurnedOn || !model || !stackFrame || ( model.uri.toString()) !== ( stackFrame.source.uri.toString())) {
+            if (!this.removeInlineValuesScheduler.isScheduled()) {
+                this.removeInlineValuesScheduler.schedule();
+            }
+            return;
+        }
+        this.removeInlineValuesScheduler.cancel();
+        this.displayedStore.clear();
+        const viewRanges = this.editor.getVisibleRangesPlusViewportAboveBelow();
+        let allDecorations;
+        const cts = ( new CancellationTokenSource());
+        this.displayedStore.add(toDisposable(() => cts.dispose(true)));
+        if (( this.languageFeaturesService.inlineValuesProvider.has(model))) {
+            const findVariable = async (_key, caseSensitiveLookup) => {
+                const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
+                const key = caseSensitiveLookup ? _key : _key.toLowerCase();
+                for (const scope of scopes) {
+                    const variables = await scope.getChildren();
+                    const found = variables.find(v => caseSensitiveLookup ? (v.name === key) : (v.name.toLowerCase() === key));
+                    if (found) {
+                        return found.value;
+                    }
+                }
+                return undefined;
+            };
+            const ctx = {
+                frameId: stackFrame.frameId,
+                stoppedLocation: ( new Range(
+                    stackFrame.range.startLineNumber,
+                    stackFrame.range.startColumn + 1,
+                    stackFrame.range.endLineNumber,
+                    stackFrame.range.endColumn + 1
+                ))
+            };
+            const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
+            allDecorations = [];
+            const lineDecorations = ( new Map());
+            const promises = providers.flatMap(provider => ( viewRanges.map(
+                range => Promise.resolve(provider.provideInlineValues(model, range, ctx, cts.token)).then(async (result) => {
+                    if (result) {
+                        for (const iv of result) {
+                            let text = undefined;
+                            switch (iv.type) {
+                                case 'text':
+                                    text = iv.text;
+                                    break;
+                                case 'variable': {
+                                    let va = iv.variableName;
+                                    if (!va) {
+                                        const lineContent = model.getLineContent(iv.range.startLineNumber);
+                                        va = lineContent.substring(iv.range.startColumn - 1, iv.range.endColumn - 1);
+                                    }
+                                    const value = await findVariable(va, iv.caseSensitiveLookup);
+                                    if (value) {
+                                        text = format(var_value_format, va, value);
+                                    }
+                                    break;
+                                }
+                                case 'expression': {
+                                    let expr = iv.expression;
+                                    if (!expr) {
+                                        const lineContent = model.getLineContent(iv.range.startLineNumber);
+                                        expr = lineContent.substring(iv.range.startColumn - 1, iv.range.endColumn - 1);
+                                    }
+                                    if (expr) {
+                                        const expression = ( new Expression(expr));
+                                        await expression.evaluate(stackFrame.thread.session, stackFrame, 'watch', true);
+                                        if (expression.available) {
+                                            text = format(var_value_format, expr, expression.value);
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                            if (text) {
+                                const line = iv.range.startLineNumber;
+                                let lineSegments = lineDecorations.get(line);
+                                if (!lineSegments) {
+                                    lineSegments = [];
+                                    lineDecorations.set(line, lineSegments);
+                                }
+                                if (!( lineSegments.some(iv => iv.text === text))) {
+                                    lineSegments.push(( new InlineSegment(iv.range.startColumn, text)));
+                                }
+                            }
+                        }
+                    }
+                }, err => {
+                    onUnexpectedExternalError(err);
+                })
+            )));
+            const startTime = Date.now();
+            await Promise.all(promises);
+            this.updateInlineValuesScheduler.delay = this.debounceInfo.update(model, Date.now() - startTime);
+            lineDecorations.forEach((segments, line) => {
+                if (segments.length > 0) {
+                    segments = segments.sort((a, b) => a.column - b.column);
+                    const text = ( segments.map(s => s.text)).join(separator);
+                    allDecorations.push(...createInlineValueDecoration(line, text));
+                }
+            });
+        }
+        else {
+            const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
+            const decorationsPerScope = await Promise.all(( scopes.map(async (scope) => {
+                const variables = await scope.getChildren();
+                let scopeRange = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
+                if (scope.range) {
+                    scopeRange = scopeRange.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
+                }
+                const ownRanges = ( viewRanges.map(r => r.intersectRanges(scopeRange))).filter(isDefined);
+                this._wordToLineNumbersMap ??= ( new WordsToLineNumbersCache(model));
+                for (const range of ownRanges) {
+                    this._wordToLineNumbersMap.ensureRangePopulated(range);
+                }
+                return createInlineValueDecorationsInsideRange(variables, ownRanges, model, this._wordToLineNumbersMap.value);
+            })));
+            allDecorations = distinct(decorationsPerScope.flat(),
+            decoration => `${decoration.range.startLineNumber}:${decoration?.options.after?.content}`);
+        }
+        if (!cts.token.isCancellationRequested) {
+            this.oldDecorations.set(allDecorations);
+            this.displayedStore.add(toDisposable(() => this.oldDecorations.clear()));
+        }
+    }
+    dispose() {
+        if (this.hoverWidget) {
+            this.hoverWidget.dispose();
+        }
+        if (this.configurationWidget) {
+            this.configurationWidget.dispose();
+        }
+        this.toDispose = dispose(this.toDispose);
+    }
+};
+DebugEditorContribution.__decorator = ( __decorate([
+    memoize
+], DebugEditorContribution.prototype, "showHoverScheduler", null));
+DebugEditorContribution.__decorator = ( __decorate([
+    memoize
+], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null));
+DebugEditorContribution.__decorator = ( __decorate([
+    memoize
+], DebugEditorContribution.prototype, "updateInlineValuesScheduler", null));
+DebugEditorContribution = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IHostService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, ILanguageFeaturesService)),
+    ( __param(9, ILanguageFeatureDebounceService))
+], DebugEditorContribution));
+class WordsToLineNumbersCache {
+    constructor(model) {
+        this.model = model;
+        this.value = ( new Map());
+        this.intervals = ( new Uint8Array(Math.ceil(model.getLineCount() / 8)));
+    }
+    ensureRangePopulated(range) {
+        for (let lineNumber = range.startLineNumber; lineNumber <= range.endLineNumber; lineNumber++) {
+            const bin = lineNumber >> 3;
+            const bit = 1 << (lineNumber & 0b111);
+            if (!(this.intervals[bin] & bit)) {
+                getWordToLineNumbersMap(this.model, lineNumber, this.value);
+                this.intervals[bin] |= bit;
+            }
+        }
+    }
+}
+CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor, uri, iRange, context) => {
+    assertType(URI.isUri(uri));
+    assertType(Range.isIRange(iRange));
+    if (!context || typeof context.frameId !== 'number' || !Range.isIRange(context.stoppedLocation)) {
+        throw illegalArgument('context');
+    }
+    const model = accessor.get(IModelService).getModel(uri);
+    if (!model) {
+        throw illegalArgument('uri');
+    }
+    const range = Range.lift(iRange);
+    const { inlineValuesProvider } = accessor.get(ILanguageFeaturesService);
+    const providers = inlineValuesProvider.ordered(model);
+    const providerResults = await Promise.all(( providers.map(
+        provider => provider.provideInlineValues(model, range, context, CancellationToken.None)
+    )));
+    return providerResults.flat().filter(isDefined);
+});
+
+export { DebugEditorContribution };