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

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

@@ -1,725 +0,0 @@
-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 { flatten, 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, 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/colorRegistry';
-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.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.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.oldDecorations.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();
-        const viewRanges = this.editor.getVisibleRangesPlusViewportAboveBelow();
-        let allDecorations;
-        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 token = ( new CancellationTokenSource()).token;
-            const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
-            allDecorations = [];
-            const lineDecorations = ( new Map());
-            const promises = flatten(( providers.map(provider => ( viewRanges.map(
-                range => Promise.resolve(provider.provideInlineValues(model, range, ctx, 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.reduce((previous, current) => previous.concat(current), []),
-            decoration => `${decoration.range.startLineNumber}:${decoration?.options.after?.content}`);
-        }
-        this.oldDecorations.set(allDecorations);
-    }
-    dispose() {
-        if (this.hoverWidget) {
-            this.hoverWidget.dispose();
-        }
-        if (this.configurationWidget) {
-            this.configurationWidget.dispose();
-        }
-        this.toDispose = dispose(this.toDispose);
-        this.oldDecorations.clear();
-    }
-};
-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 };