@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,679 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/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) {
-                        this.showEditorHover(this.hoverPosition, 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)) {
-            const result = await this.hoverWidget.showAt(position, focus);
-            if (result === 1 ) {
-                this.showEditorHover(position, focus);
-            }
-        }
-        else {
-            this.showEditorHover(position, focus);
-        }
-    }
-    showEditorHover(position, focus) {
-        const hoverController = this.editor.getContribution(ModesHoverController.ID);
-        const range = ( new Range(position.lineNumber, position.column, position.lineNumber, position.column));
-        hoverController?.showContentHover(range, 1 , 0 , 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(59 );
-        const scheduler = ( new RunOnceScheduler(() => {
-            if (this.hoverPosition && !this.altPressed) {
-                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 };