@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,675 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { visit } from 'monaco-editor/esm/vs/base/common/json.js';
+import { setProperty } from '../../../../base/common/jsonEdit.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { CoreEditingCommands } from 'monaco-editor/esm/vs/editor/browser/coreCommands.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { DEFAULT_WORD_REGEXP } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { InjectedTextCursorStops } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { ILanguageFeatureDebounceService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatureDebounce.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ModesHoverController } from 'monaco-editor/esm/vs/editor/contrib/hover/browser/hover.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { DebugHoverWidget } from './debugHover.js';
+import { ExceptionWidget } from './exceptionWidget.js';
+import { CONTEXT_EXCEPTION_WIDGET_VISIBLE, IDebugService } from '../common/debug.js';
+import { Expression } from '../common/debugModel.js';
+import { IHostService } from '../../../services/host/browser/host.js';
+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'
+}, ( nls.localize('editor.inlineValuesForeground', "Color for the debug inline value text.")));
+registerColor('editor.inlineValuesBackground', {
+    dark: '#ffc80033',
+    light: '#ffc80033',
+    hcDark: '#ffc80033',
+    hcLight: '#ffc80033'
+}, ( nls.localize(
+    '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: strings.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, strings.noBreakWhitespace);
+}
+function createInlineValueDecorationsInsideRange(expressions, range, 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 (range.containsPosition(( new Position(lineNumber, 0)))) {
+                    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) {
+    const result = ( new Map());
+    if (!model) {
+        return result;
+    }
+    for (let lineNumber = 1, len = model.getLineCount(); lineNumber <= len; ++lineNumber) {
+        const lineContent = model.getLineContent(lineNumber);
+        if (lineContent.length > MAX_TOKENIZATION_LINE_LEN) {
+            continue;
+        }
+        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);
+                }
+            }
+        }
+    }
+    return result;
+}
+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.altPressed = false;
+        this.oldDecorations = this.editor.createDecorationsCollection();
+        this._wordToLineNumbersMap = undefined;
+        this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
+        this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
+        this.toDispose = [];
+        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.updateHoverConfiguration();
+            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.debugService.onDidChangeState((state) => {
+            if (state !== 2 ) {
+                this.toggleExceptionWidget();
+            }
+        }));
+    }
+    get wordToLineNumbersMap() {
+        if (!this._wordToLineNumbersMap) {
+            this._wordToLineNumbersMap = getWordToLineNumbersMap(this.editor.getModel());
+        }
+        return this._wordToLineNumbersMap;
+    }
+    updateHoverConfiguration() {
+        const stackFrame = this.debugService.getViewModel().focusedStackFrame;
+        const model = this.editor.getModel();
+        if (model) {
+            this.applyHoverConfiguration(model, stackFrame);
+        }
+    }
+    applyHoverConfiguration(model, stackFrame) {
+        if (stackFrame && this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) {
+            if (this.altListener) {
+                this.altListener.dispose();
+            }
+            this.altListener = addDisposableListener(document, 'keydown', keydownEvent => {
+                const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
+                if (standardKeyboardEvent.keyCode === 6 ) {
+                    this.altPressed = true;
+                    const debugHoverWasVisible = this.hoverWidget.isVisible();
+                    this.hoverWidget.hide();
+                    this.enableEditorHover();
+                    if (debugHoverWasVisible && this.hoverPosition) {
+                        const hoverController = this.editor.getContribution(ModesHoverController.ID);
+                        const range = ( new Range(
+                            this.hoverPosition.lineNumber,
+                            this.hoverPosition.column,
+                            this.hoverPosition.lineNumber,
+                            this.hoverPosition.column
+                        ));
+                        hoverController?.showContentHover(range, 1 , 0 , false);
+                    }
+                    const onKeyUp = ( new DomEmitter(document, 'keyup'));
+                    const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
+                        let standardKeyboardEvent = undefined;
+                        if (keyupEvent instanceof KeyboardEvent) {
+                            standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
+                        }
+                        if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
+                            this.altPressed = false;
+                            this.editor.updateOptions({ hover: { enabled: false } });
+                            listener.dispose();
+                            onKeyUp.dispose();
+                        }
+                    });
+                }
+            });
+            this.editor.updateOptions({ hover: { enabled: false } });
+        }
+        else {
+            this.altListener?.dispose();
+            this.enableEditorHover();
+        }
+    }
+    enableEditorHover() {
+        if (this.editor.hasModel()) {
+            const model = this.editor.getModel();
+            const overrides = {
+                resource: model.uri,
+                overrideIdentifier: model.getLanguageId()
+            };
+            const defaultConfiguration = this.configurationService.getValue('editor.hover', overrides);
+            this.editor.updateOptions({
+                hover: {
+                    enabled: defaultConfiguration.enabled,
+                    delay: defaultConfiguration.delay,
+                    sticky: defaultConfiguration.sticky
+                }
+            });
+        }
+    }
+    async showHover(position, focus) {
+        const sf = this.debugService.getViewModel().focusedStackFrame;
+        const model = this.editor.getModel();
+        if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri) && !this.altPressed) {
+            return this.hoverWidget.showAt(position, focus);
+        }
+    }
+    async onFocusStackFrame(sf) {
+        const model = this.editor.getModel();
+        if (model) {
+            this.applyHoverConfiguration(model, sf);
+            if (sf && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
+                await this.toggleExceptionWidget();
+            }
+            else {
+                this.hideHoverWidget();
+            }
+        }
+        await this.updateInlineValueDecorations(sf);
+    }
+    get showHoverScheduler() {
+        const hoverOption = this.editor.getOption(58 );
+        const scheduler = ( new RunOnceScheduler(() => {
+            if (this.hoverPosition) {
+                this.showHover(this.hoverPosition, false);
+            }
+        }, hoverOption.delay * 2));
+        this.toDispose.push(scheduler);
+        return scheduler;
+    }
+    get hideHoverScheduler() {
+        const scheduler = ( new RunOnceScheduler(() => {
+            if (!this.hoverWidget.isHovered()) {
+                this.hoverWidget.hide();
+            }
+        }, 0));
+        this.toDispose.push(scheduler);
+        return scheduler;
+    }
+    hideHoverWidget() {
+        if (!this.hideHoverScheduler.isScheduled() && this.hoverWidget.willBeVisible()) {
+            this.hideHoverScheduler.schedule();
+        }
+        this.showHoverScheduler.cancel();
+    }
+    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 = platform.isMacintosh ? 'metaKey' : 'ctrlKey';
+        if (!this.altPressed) {
+            if (target.type === 2 ) {
+                this.editor.updateOptions({ hover: { enabled: true } });
+                this.gutterIsHovered = true;
+            }
+            else if (this.gutterIsHovered) {
+                this.gutterIsHovered = false;
+                this.updateHoverConfiguration();
+            }
+        }
+        if (target.type === 9  && target.detail === DebugHoverWidget.ID && !mouseEvent.event[stopKey]) {
+            return;
+        }
+        if (target.type === 6 ) {
+            if (target.position && !Position.equals(target.position, this.hoverPosition)) {
+                this.hoverPosition = target.position;
+                this.hideHoverScheduler.cancel();
+                this.showHoverScheduler.schedule();
+            }
+        }
+        else if (!this.mouseDown) {
+            this.hideHoverWidget();
+        }
+    }
+    onKeyDown(e) {
+        const stopKey = platform.isMacintosh ? 57  : 5 ;
+        if (e.keyCode !== stopKey) {
+            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();
+        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 ranges = this.editor.getVisibleRangesPlusViewportAboveBelow();
+            const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
+            allDecorations = [];
+            const lineDecorations = ( new Map());
+            const promises = flatten(( providers.map(provider => ( ranges.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 = strings.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 = strings.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 range = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
+                if (scope.range) {
+                    range = range.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
+                }
+                return createInlineValueDecorationsInsideRange(variables, range, model, this.wordToLineNumbersMap);
+            })));
+            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, "hideHoverScheduler", 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));
+export { DebugEditorContribution };