@codingame/monaco-vscode-api 25.1.1 → 26.0.0

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

@@ -66,13 +66,13 @@ 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'
-}, ( localize(6804, "Color for the debug inline value text.")));
-registerColor('editor.inlineValuesBackground', '#ffc80033', ( localize(6805, "Color for the debug inline value background.")));
+registerColor("editor.inlineValuesForeground", {
+    dark: "#ffffff80",
+    light: "#00000080",
+    hcDark: "#ffffff80",
+    hcLight: "#00000080"
+}, ( localize(7115, "Color for the debug inline value text.")));
+registerColor("editor.inlineValuesBackground", "#ffc80033", ( localize(7116, "Color for the debug inline value background.")));
 class InlineSegment {
     constructor(column, text) {
         this.column = column;
@@ -80,18 +80,18 @@ class InlineSegment {
     }
 }
 function formatHoverContent(contentText) {
-    if (contentText.includes(',') && contentText.includes('=')) {
-        const customSplit = (text) => {
+    if (contentText.includes(",") && contentText.includes("=")) {
+        const customSplit = text => {
             const splits = [];
             let equalsFound = 0;
             let start = 0;
             for (let i = 0; i < text.length; i++) {
-                if (text[i] === '=') {
+                if (text[i] === "=") {
                     if (equalsFound === 0) {
                         equalsFound++;
                         continue;
                     }
-                    const commaIndex = text.lastIndexOf(',', i);
+                    const commaIndex = text.lastIndexOf(",", i);
                     if (commaIndex !== -1 && commaIndex >= start) {
                         splits.push(commaIndex);
                         start = commaIndex + 1;
@@ -112,60 +112,63 @@ function formatHoverContent(contentText) {
         };
         const pairs = customSplit(contentText);
         const formattedPairs = ( pairs.map(pair => {
-            const equalsIndex = pair.indexOf('=');
+            const equalsIndex = pair.indexOf("=");
             if (equalsIndex !== -1) {
-                const indent = ' '.repeat(equalsIndex + 2);
+                const indent = " ".repeat(equalsIndex + 2);
                 const [firstLine, ...restLines] = pair.split(/\r?\n/);
-                return [firstLine, ...( restLines.map(line => indent + line))].join('\n');
+                return [firstLine, ...( restLines.map(line => indent + line))].join("\n");
             }
             return pair;
         }));
-        return ( new MarkdownString()).appendCodeblock('', formattedPairs.join(',\n'));
+        return ( new MarkdownString()).appendCodeblock("", formattedPairs.join(",\n"));
     }
-    return ( new MarkdownString()).appendCodeblock('', contentText);
+    return ( new MarkdownString()).appendCodeblock("", contentText);
 }
-function createInlineValueDecoration(lineNumber, contentText, classNamePrefix, column = Constants.MAX_SAFE_SMALL_INTEGER, viewportMaxCol = MAX_INLINE_DECORATOR_LENGTH) {
+function createInlineValueDecoration(
+    lineNumber,
+    contentText,
+    classNamePrefix,
+    column = Constants.MAX_SAFE_SMALL_INTEGER,
+    viewportMaxCol = MAX_INLINE_DECORATOR_LENGTH
+) {
     const rawText = contentText;
     if (contentText.length > viewportMaxCol) {
-        contentText = contentText.substring(0, viewportMaxCol) + '...';
-    }
-    return [
-        {
-            range: {
-                startLineNumber: lineNumber,
-                endLineNumber: lineNumber,
-                startColumn: column,
-                endColumn: column
-            },
-            options: {
-                description: `${classNamePrefix}-inline-value-decoration-spacer`,
-                after: {
-                    content: noBreakWhitespace,
-                    cursorStops: InjectedTextCursorStops.None
-                },
-                showIfCollapsed: true,
-            }
+        contentText = contentText.substring(0, viewportMaxCol) + "...";
+    }
+    return [{
+        range: {
+            startLineNumber: lineNumber,
+            endLineNumber: lineNumber,
+            startColumn: column,
+            endColumn: column
         },
-        {
-            range: {
-                startLineNumber: lineNumber,
-                endLineNumber: lineNumber,
-                startColumn: column,
-                endColumn: column
+        options: {
+            description: `${classNamePrefix}-inline-value-decoration-spacer`,
+            after: {
+                content: noBreakWhitespace,
+                cursorStops: InjectedTextCursorStops.None
             },
-            options: {
-                description: `${classNamePrefix}-inline-value-decoration`,
-                after: {
-                    content: replaceWsWithNoBreakWs(contentText),
-                    inlineClassName: `${classNamePrefix}-inline-value`,
-                    inlineClassNameAffectsLetterSpacing: true,
-                    cursorStops: InjectedTextCursorStops.None
-                },
-                showIfCollapsed: true,
-                hoverMessage: formatHoverContent(rawText)
-            }
+            showIfCollapsed: true
+        }
+    }, {
+        range: {
+            startLineNumber: lineNumber,
+            endLineNumber: lineNumber,
+            startColumn: column,
+            endColumn: column
         },
-    ];
+        options: {
+            description: `${classNamePrefix}-inline-value-decoration`,
+            after: {
+                content: replaceWsWithNoBreakWs(contentText),
+                inlineClassName: `${classNamePrefix}-inline-value`,
+                inlineClassNameAffectsLetterSpacing: true,
+                cursorStops: InjectedTextCursorStops.None
+            },
+            showIfCollapsed: true,
+            hoverMessage: formatHoverContent(rawText)
+        }
+    }];
 }
 function replaceWsWithNoBreakWs(str) {
     return str.replace(/[ \t\n]/g, noBreakWhitespace);
@@ -199,7 +202,10 @@ function createInlineValueDecorationsInsideRange(expressions, ranges, model, wor
         variables: ( names.sort((first, second) => {
             const content = model.getLineContent(line);
             return content.indexOf(first) - content.indexOf(second);
-        }).map(name => ({ name, value: nameValueMap.get(name) })))
+        }).map(name => ({
+            name,
+            value: nameValueMap.get(name)
+        })))
     })));
 }
 function getWordToLineNumbersMap(model, lineNumber, result) {
@@ -229,7 +235,19 @@ function getWordToLineNumbersMap(model, lineNumber, result) {
     }
 }
 let DebugEditorContribution = class DebugEditorContribution {
-    constructor(editor, debugService, instantiationService, commandService, configurationService, hostService, uriIdentityService, contextKeyService, languageFeaturesService, featureDebounceService, editorService) {
+    constructor(
+        editor,
+        debugService,
+        instantiationService,
+        commandService,
+        configurationService,
+        hostService,
+        uriIdentityService,
+        contextKeyService,
+        languageFeaturesService,
+        featureDebounceService,
+        editorService
+    ) {
         this.editor = editor;
         this.debugService = debugService;
         this.instantiationService = instantiationService;
@@ -248,7 +266,9 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.shouldScrollToExceptionWidget = () => this.allowScrollToExceptionWidget;
         this.defaultHoverLockout = ( new MutableDisposable());
         this.oldDecorations = this.editor.createDecorationsCollection();
-        this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
+        this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, "InlineValues", {
+            min: DEAFULT_INLINE_DEBOUNCE_DELAY
+        });
         this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
         this.toDispose = [this.defaultHoverLockout, this.altListener, this.displayedStore];
         this.registerListeners();
@@ -256,11 +276,13 @@ let DebugEditorContribution = class DebugEditorContribution {
         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.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) => {
+        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;
@@ -270,13 +292,17 @@ let DebugEditorContribution = class DebugEditorContribution {
                 this.hideHoverWidget();
             }
         }));
-        this.toDispose.push(this.editor.onKeyDown((e) => this.onKeyDown(e)));
+        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.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();
@@ -292,12 +318,12 @@ let DebugEditorContribution = class DebugEditorContribution {
                 this.updateInlineValuesScheduler.schedule();
             }
         }));
-        this.toDispose.push(this.configurationService.onDidChangeConfiguration((e) => {
-            if (e.affectsConfiguration('editor.hover')) {
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("editor.hover")) {
                 this.updateHoverConfiguration();
             }
         }));
-        this.toDispose.push(this.debugService.onDidChangeState((state) => {
+        this.toDispose.push(this.debugService.onDidChangeState(state => {
             if (state !== State.Stopped) {
                 this.toggleExceptionWidget();
             }
@@ -307,7 +333,7 @@ let DebugEditorContribution = class DebugEditorContribution {
     updateHoverConfiguration() {
         const model = this.editor.getModel();
         if (model) {
-            this.editorHoverOptions = this.configurationService.getValue('editor.hover', {
+            this.editorHoverOptions = this.configurationService.getValue("editor.hover", {
                 resource: model.uri,
                 overrideIdentifier: model.getLanguageId()
             });
@@ -326,7 +352,7 @@ let DebugEditorContribution = class DebugEditorContribution {
             return;
         }
         const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
-        this.altListener.value = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
+        this.altListener.value = addDisposableListener(ownerDocument, "keydown", keydownEvent => {
             const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
             if (standardKeyboardEvent.keyCode === KeyCode.Alt) {
                 this.altPressed = true;
@@ -336,7 +362,7 @@ let DebugEditorContribution = class DebugEditorContribution {
                 if (debugHoverWasVisible && this.hoverPosition) {
                     this.showEditorHover(this.hoverPosition.position, false);
                 }
-                const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
+                const onKeyUp = ( new DomEmitter(ownerDocument, "keyup"));
                 const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
                     let standardKeyboardEvent = undefined;
                     if (isKeyboardEvent(keyupEvent)) {
@@ -361,22 +387,27 @@ let DebugEditorContribution = class DebugEditorContribution {
             if (result === ShowDebugHoverResult.NOT_AVAILABLE) {
                 this.showEditorHover(position, focus);
             }
-        }
-        else {
+        } else {
             this.showEditorHover(position, focus);
         }
     }
     preventDefaultEditorHover() {
-        if (this.defaultHoverLockout.value || this.editorHoverOptions?.enabled === 'off') {
+        if (this.defaultHoverLockout.value || this.editorHoverOptions?.enabled === "off") {
             return;
         }
         const hoverController = this.editor.getContribution(ContentHoverController.ID);
         hoverController?.hideContentHover();
-        this.editor.updateOptions({ hover: { enabled: 'off' } });
+        this.editor.updateOptions({
+            hover: {
+                enabled: "off"
+            }
+        });
         this.defaultHoverLockout.value = {
             dispose: () => {
                 this.editor.updateOptions({
-                    hover: { enabled: this.editorHoverOptions?.enabled ?? 'on' }
+                    hover: {
+                        enabled: this.editorHoverOptions?.enabled ?? "on"
+                    }
                 });
             }
         };
@@ -393,8 +424,7 @@ let DebugEditorContribution = class DebugEditorContribution {
             this.applyDocumentListeners(model, sf);
             if (sf && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
                 await this.toggleExceptionWidget();
-            }
-            else {
+            } else {
                 this.hideHoverWidget();
             }
         }
@@ -433,19 +463,17 @@ let DebugEditorContribution = class DebugEditorContribution {
             return;
         }
         const target = mouseEvent.target;
-        const stopKey = isMacintosh ? 'metaKey' : 'ctrlKey';
+        const stopKey = isMacintosh ? "metaKey" : "ctrlKey";
         if (!this.altPressed) {
             if (target.type === MouseTargetType.GUTTER_GLYPH_MARGIN) {
                 this.defaultHoverLockout.clear();
                 this.gutterIsHovered = true;
-            }
-            else if (this.gutterIsHovered) {
+            } else if (this.gutterIsHovered) {
                 this.gutterIsHovered = false;
                 this.updateHoverConfiguration();
             }
         }
-        if ((target.type === MouseTargetType.CONTENT_WIDGET && target.detail === DebugHoverWidget.ID)
-            || this.hoverWidget.isInSafeTriangle(mouseEvent.event.posx, mouseEvent.event.posy)) {
+        if ((target.type === MouseTargetType.CONTENT_WIDGET && target.detail === DebugHoverWidget.ID) || this.hoverWidget.isInSafeTriangle(mouseEvent.event.posx, mouseEvent.event.posy)) {
             const sticky = this.editorHoverOptions?.sticky ?? true;
             if (sticky || this.hoverWidget.isShowingComplexValue || mouseEvent.event[stopKey]) {
                 return;
@@ -453,12 +481,14 @@ let DebugEditorContribution = class DebugEditorContribution {
         }
         if (target.type === MouseTargetType.CONTENT_TEXT) {
             if (target.position && !Position.equals(target.position, this.hoverPosition?.position || null) && !this.hoverWidget.isInSafeTriangle(mouseEvent.event.posx, mouseEvent.event.posy)) {
-                this.hoverPosition = { position: target.position, event: mouseEvent.event };
+                this.hoverPosition = {
+                    position: target.position,
+                    event: mouseEvent.event
+                };
                 this.preventDefaultEditorHover();
                 this.showHoverScheduler.schedule(this.hoverDelay);
             }
-        }
-        else if (!this.mouseDown) {
+        } else if (!this.mouseDown) {
             this.hideHoverWidget();
         }
     }
@@ -476,7 +506,9 @@ let DebugEditorContribution = class DebugEditorContribution {
             this.closeExceptionWidget();
             return;
         }
-        const exceptionSf = callStack.find(sf => !!(sf && sf.source && sf.source.available && sf.source.presentationHint !== 'deemphasize'));
+        const exceptionSf = callStack.find(
+            sf => !!(sf && sf.source && sf.source.available && sf.source.presentationHint !== "deemphasize")
+        );
         if (!exceptionSf || exceptionSf !== focusedSf) {
             this.closeExceptionWidget();
             return;
@@ -484,17 +516,25 @@ let DebugEditorContribution = class DebugEditorContribution {
         const sameUri = this.uriIdentityService.extUri.isEqual(exceptionSf.source.uri, model.uri);
         if (this.exceptionWidget && !sameUri) {
             this.closeExceptionWidget();
-        }
-        else if (sameUri) {
+        } else if (sameUri) {
             const activeControl = this.editorService.activeTextEditorControl;
             const isActiveEditor = activeControl === this.editor;
             const exceptionInfo = await focusedSf.thread.exceptionInfo;
             if (exceptionInfo) {
                 if (isActiveEditor) {
-                    this.showExceptionWidget(exceptionInfo, this.debugService.getViewModel().focusedSession, exceptionSf.range.startLineNumber, exceptionSf.range.startColumn);
-                }
-                else {
-                    this.showExceptionWidgetWithoutScroll(exceptionInfo, this.debugService.getViewModel().focusedSession, exceptionSf.range.startLineNumber, exceptionSf.range.startColumn);
+                    this.showExceptionWidget(
+                        exceptionInfo,
+                        this.debugService.getViewModel().focusedSession,
+                        exceptionSf.range.startLineNumber,
+                        exceptionSf.range.startColumn
+                    );
+                } else {
+                    this.showExceptionWidgetWithoutScroll(
+                        exceptionInfo,
+                        this.debugService.getViewModel().focusedSession,
+                        exceptionSf.range.startLineNumber,
+                        exceptionSf.range.startColumn
+                    );
                 }
             }
         }
@@ -503,14 +543,23 @@ let DebugEditorContribution = class DebugEditorContribution {
         if (this.exceptionWidget) {
             this.exceptionWidget.dispose();
         }
-        this.exceptionWidget = this.instantiationService.createInstance(ExceptionWidget, this.editor, exceptionInfo, debugSession, this.shouldScrollToExceptionWidget);
-        this.exceptionWidget.show({ lineNumber, column }, 0);
+        this.exceptionWidget = this.instantiationService.createInstance(
+            ExceptionWidget,
+            this.editor,
+            exceptionInfo,
+            debugSession,
+            this.shouldScrollToExceptionWidget
+        );
+        this.exceptionWidget.show({
+            lineNumber,
+            column
+        }, 0);
         this.exceptionWidget.focus();
         this.editor.revealRangeInCenter({
             startLineNumber: lineNumber,
             startColumn: column,
             endLineNumber: lineNumber,
-            endColumn: column,
+            endColumn: column
         });
         this.exceptionWidgetVisible.set(true);
     }
@@ -522,15 +571,33 @@ let DebugEditorContribution = class DebugEditorContribution {
         const currentScrollTop = this.editor.getScrollTop();
         const visibleRanges = this.editor.getVisibleRanges();
         if (visibleRanges.length === 0) {
-            this.exceptionWidget = this.instantiationService.createInstance(ExceptionWidget, this.editor, exceptionInfo, debugSession, this.shouldScrollToExceptionWidget);
-            this.exceptionWidget.show({ lineNumber, column }, 0);
+            this.exceptionWidget = this.instantiationService.createInstance(
+                ExceptionWidget,
+                this.editor,
+                exceptionInfo,
+                debugSession,
+                this.shouldScrollToExceptionWidget
+            );
+            this.exceptionWidget.show({
+                lineNumber,
+                column
+            }, 0);
             this.exceptionWidgetVisible.set(true);
             this.allowScrollToExceptionWidget = true;
             return;
         }
         const firstVisibleLine = visibleRanges[0].startLineNumber;
-        this.exceptionWidget = this.instantiationService.createInstance(ExceptionWidget, this.editor, exceptionInfo, debugSession, this.shouldScrollToExceptionWidget);
-        this.exceptionWidget.show({ lineNumber, column }, 0);
+        this.exceptionWidget = this.instantiationService.createInstance(
+            ExceptionWidget,
+            this.editor,
+            exceptionInfo,
+            debugSession,
+            this.shouldScrollToExceptionWidget
+        );
+        this.exceptionWidget.show({
+            lineNumber,
+            column
+        }, 0);
         this.exceptionWidgetVisible.set(true);
         if (lineNumber < firstVisibleLine) {
             const scrollAdjustment = this.exceptionWidget.getWhitespaceHeight();
@@ -559,11 +626,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         const getConfigurationPosition = () => {
             let depthInArray = 0;
             visit(model.getValue(), {
-                onObjectProperty: (property) => {
+                onObjectProperty: property => {
                     lastProperty = property;
                 },
-                onArrayBegin: (offset) => {
-                    if (lastProperty === 'configurations' && depthInArray === 0) {
+                onArrayBegin: offset => {
+                    if (lastProperty === "configurations" && depthInArray === 0) {
                         configurationsArrayPosition = model.getPositionAt(offset + 1);
                     }
                     depthInArray++;
@@ -575,11 +642,22 @@ let DebugEditorContribution = class DebugEditorContribution {
         };
         getConfigurationPosition();
         if (!configurationsArrayPosition) {
-            const { tabSize, insertSpaces } = model.getOptions();
+            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 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(
@@ -595,10 +673,10 @@ let DebugEditorContribution = class DebugEditorContribution {
             return;
         }
         this.editor.focus();
-        const insertLine = (position) => {
+        const insertLine = position => {
             if (model.getLineLastNonWhitespaceColumn(position.lineNumber) > position.column) {
                 this.editor.setPosition(position);
-                this.instantiationService.invokeFunction((accessor) => {
+                this.instantiationService.invokeFunction(accessor => {
                     CoreEditingCommands.LineBreakInsert.runEditorCommand(accessor, this.editor, null);
                 });
             }
@@ -606,7 +684,7 @@ let DebugEditorContribution = class DebugEditorContribution {
             return this.commandService.executeCommand(InsertLineAfterAction.ID);
         };
         await insertLine(configurationsArrayPosition);
-        await this.commandService.executeCommand('editor.action.triggerSuggest');
+        await this.commandService.executeCommand("editor.action.triggerSuggest");
     }
     get removeInlineValuesScheduler() {
         return ( new RunOnceScheduler(() => {
@@ -622,11 +700,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         ));
     }
     async updateInlineValueDecorations(stackFrame) {
-        const var_value_format = '{0} = {1}';
-        const separator = ', ';
+        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)));
+        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();
@@ -645,7 +723,9 @@ let DebugEditorContribution = class DebugEditorContribution {
                 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));
+                    const found = variables.find(
+                        v => caseSensitiveLookup ? (v.name === key) : (v.name.toLowerCase() === key)
+                    );
                     if (found) {
                         return found.value;
                     }
@@ -665,15 +745,16 @@ let DebugEditorContribution = class DebugEditorContribution {
             allDecorations = [];
             const lineDecorations = ( new Map());
             const promises = providers.flatMap(provider => ( viewRanges.map(
-                range => Promise.resolve(provider.provideInlineValues(model, range, ctx, cts.token)).then(async (result) => {
+                range => Promise.resolve(provider.provideInlineValues(model, range, ctx, cts.token)).then(async result => {
                     if (result) {
                         for (const iv of result) {
                             let text = undefined;
                             switch (iv.type) {
-                                case 'text':
-                                    text = iv.text;
-                                    break;
-                                case 'variable': {
+                            case "text":
+                                text = iv.text;
+                                break;
+                            case "variable":
+                                {
                                     let va = iv.variableName;
                                     if (!va) {
                                         const lineContent = model.getLineContent(iv.range.startLineNumber);
@@ -685,7 +766,8 @@ let DebugEditorContribution = class DebugEditorContribution {
                                     }
                                     break;
                                 }
-                                case 'expression': {
+                            case "expression":
+                                {
                                     let expr = iv.expression;
                                     if (!expr) {
                                         const lineContent = model.getLineContent(iv.range.startLineNumber);
@@ -693,7 +775,7 @@ let DebugEditorContribution = class DebugEditorContribution {
                                     }
                                     if (expr) {
                                         const expression = ( new Expression(expr));
-                                        await expression.evaluate(stackFrame.thread.session, stackFrame, 'watch', true);
+                                        await expression.evaluate(stackFrame.thread.session, stackFrame, "watch", true);
                                         if (expression.available) {
                                             text = format(var_value_format, expr, expression.value);
                                         }
@@ -728,15 +810,22 @@ let DebugEditorContribution = class DebugEditorContribution {
                     const editorWidth = this.editor.getLayoutInfo().width;
                     const fontInfo = this.editor.getOption(EditorOption.fontInfo);
                     const viewportMaxCol = Math.floor((editorWidth - 50) / fontInfo.typicalHalfwidthCharacterWidth);
-                    allDecorations.push(...createInlineValueDecoration(line, text, 'debug', undefined, viewportMaxCol));
+                    allDecorations.push(
+                        ...createInlineValueDecoration(line, text, "debug", undefined, viewportMaxCol)
+                    );
                 }
             });
-        }
-        else {
+        } else {
             const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
-            const scopesWithVariables = await Promise.all(( scopes.map(async (scope) => ({ scope, variables: await scope.getChildren() }))));
+            const scopesWithVariables = await Promise.all(( scopes.map(async scope => ({
+                scope,
+                variables: await scope.getChildren()
+            }))));
             const valuesPerLine = ( new Map());
-            for (const { scope, variables } of scopesWithVariables) {
+            for (const {
+                scope,
+                variables
+            } of scopesWithVariables) {
                 let scopeRange = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
                 if (scope.range) {
                     scopeRange = scopeRange.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
@@ -747,13 +836,19 @@ let DebugEditorContribution = class DebugEditorContribution {
                     this._wordToLineNumbersMap.ensureRangePopulated(range);
                 }
                 const mapped = createInlineValueDecorationsInsideRange(variables, ownRanges, model, this._wordToLineNumbersMap.value);
-                for (const { line, variables } of mapped) {
+                for (const {
+                    line,
+                    variables
+                } of mapped) {
                     let values = valuesPerLine.get(line);
                     if (!values) {
                         values = ( new Map());
                         valuesPerLine.set(line, values);
                     }
-                    for (const { name, value } of variables) {
+                    for (const {
+                        name,
+                        value
+                    } of variables) {
                         if (!( values.has(name))) {
                             values.set(name, value);
                         }
@@ -761,27 +856,33 @@ let DebugEditorContribution = class DebugEditorContribution {
                 }
             }
             allDecorations = [...valuesPerLine.entries()].flatMap(([line, values]) => {
-                const text = ( [...values].map(([n, v]) => `${n} = ${v}`)).join(', ');
+                const text = ( [...values].map(([n, v]) => `${n} = ${v}`)).join(", ");
                 const editorWidth = this.editor.getLayoutInfo().width;
                 const fontInfo = this.editor.getOption(EditorOption.fontInfo);
                 const viewportMaxCol = Math.floor((editorWidth - 50) / fontInfo.typicalHalfwidthCharacterWidth);
-                return createInlineValueDecoration(line, text, 'debug', undefined, viewportMaxCol);
+                return createInlineValueDecoration(line, text, "debug", undefined, viewportMaxCol);
             });
         }
         if (cts.token.isCancellationRequested) {
             return;
         }
         let preservePosition;
-        if (this.editor.getOption(EditorOption.wordWrap) !== 'off') {
+        if (this.editor.getOption(EditorOption.wordWrap) !== "off") {
             const position = this.editor.getPosition();
             if (position && ( this.editor.getVisibleRanges().some(r => r.containsPosition(position)))) {
-                preservePosition = { position, top: this.editor.getTopForPosition(position.lineNumber, position.column) };
+                preservePosition = {
+                    position,
+                    top: this.editor.getTopForPosition(position.lineNumber, position.column)
+                };
             }
         }
         this.oldDecorations.set(allDecorations);
         if (preservePosition) {
             const top = this.editor.getTopForPosition(preservePosition.position.lineNumber, preservePosition.position.column);
-            this.editor.setScrollTop(this.editor.getScrollTop() - (preservePosition.top - top), ScrollType.Immediate);
+            this.editor.setScrollTop(
+                this.editor.getScrollTop() - (preservePosition.top - top),
+                ScrollType.Immediate
+            );
         }
     }
     dispose() {
@@ -794,27 +895,20 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose = dispose(this.toDispose);
     }
 };
-DebugEditorContribution.__decorator = ( __decorate([
-    memoize
-], DebugEditorContribution.prototype, "showHoverScheduler", null));
-DebugEditorContribution.__decorator = ( __decorate([
-    memoize
-], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null));
-DebugEditorContribution.__decorator = ( __decorate([
-    memoize
-], DebugEditorContribution.prototype, "updateInlineValuesScheduler", null));
-DebugEditorContribution = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IHostService)),
-    ( __param(6, IUriIdentityService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, ILanguageFeaturesService)),
-    ( __param(9, ILanguageFeatureDebounceService)),
-    ( __param(10, IEditorService))
-], DebugEditorContribution));
+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)), ( __param(10, IEditorService))], DebugEditorContribution));
 class WordsToLineNumbersCache {
     constructor(model) {
         this.model = model;
@@ -832,18 +926,20 @@ class WordsToLineNumbersCache {
         }
     }
 }
-CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor, uri, iRange, context) => {
+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');
+    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');
+        throw illegalArgument("uri");
     }
     const range = Range.lift(iRange);
-    const { inlineValuesProvider } = accessor.get(ILanguageFeaturesService);
+    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)