@codingame/monaco-vscode-debug-service-override 11.1.1 → 12.0.0

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { addDisposableListener, isKeyboardEvent } from 'vscode/vscode/vs/base/browser/dom';
 import { DomEmitter } from 'vscode/vscode/vs/base/browser/event';
 import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
@@ -8,24 +9,31 @@ import { memoize } from 'vscode/vscode/vs/base/common/decorators';
 import { onUnexpectedExternalError, illegalArgument } from 'vscode/vscode/vs/base/common/errors';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { visit } from 'vscode/vscode/vs/base/common/json';
-import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
+import { setProperty } from '@codingame/monaco-vscode-56402b83-4a60-5b15-86f9-71fe99c32744-common/vscode/vs/base/common/jsonEdit';
+import { KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
 import { MutableDisposable, DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { clamp } from 'vscode/vscode/vs/base/common/numbers';
 import { basename } from 'vscode/vscode/vs/base/common/path';
 import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
 import { noBreakWhitespace, format } from 'vscode/vscode/vs/base/common/strings';
 import { isDefined, assertType } from 'vscode/vscode/vs/base/common/types';
+import { Constants } from 'vscode/vscode/vs/base/common/uint';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { CoreEditingCommands } from 'vscode/vscode/vs/editor/browser/coreCommands';
+import { MouseTargetType } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { EditorOption } from 'vscode/vscode/vs/editor/common/config/editorOptions';
 import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
 import { Position } from 'vscode/vscode/vs/editor/common/core/position';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { DEFAULT_WORD_REGEXP } from 'vscode/vscode/vs/editor/common/core/wordHelper';
+import { ScrollType } from 'vscode/vscode/vs/editor/common/editorCommon';
+import { StandardTokenType } from 'vscode/vscode/vs/editor/common/encodedTokenAttributes';
 import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
 import { ILanguageFeatureDebounceService } from 'vscode/vscode/vs/editor/common/services/languageFeatureDebounce';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
 import { ContentHoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/contentHoverController';
+import { HoverStartMode, HoverStartSource } from 'vscode/vscode/vs/editor/contrib/hover/browser/hoverOperation';
 import { localize } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
@@ -44,11 +52,11 @@ import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
-import { DebugHoverWidget } from './debugHover.js';
+import { DebugHoverWidget, ShowDebugHoverResult } from './debugHover.js';
 import { ExceptionWidget } from './exceptionWidget.js';
-import { CONTEXT_EXCEPTION_WIDGET_VISIBLE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { CONTEXT_EXCEPTION_WIDGET_VISIBLE, State } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
-import { Expression } from '@codingame/monaco-vscode-debug-notebook-common/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { Expression } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
 
 const MAX_NUM_INLINE_VALUES = 100;
@@ -60,15 +68,15 @@ registerColor('editor.inlineValuesForeground', {
     light: '#00000080',
     hcDark: '#ffffff80',
     hcLight: '#00000080'
-}, ( localize(5920, "Color for the debug inline value text.")));
-registerColor('editor.inlineValuesBackground', '#ffc80033', ( localize(5921, "Color for the debug inline value background.")));
+}, ( localize(5271, "Color for the debug inline value text.")));
+registerColor('editor.inlineValuesBackground', '#ffc80033', ( localize(5272, "Color for the debug inline value background.")));
 class InlineSegment {
     constructor(column, text) {
         this.column = column;
         this.text = text;
     }
 }
-function createInlineValueDecoration(lineNumber, contentText, column = 1073741824 ) {
+function createInlineValueDecoration(lineNumber, contentText, column = Constants.MAX_SAFE_SMALL_INTEGER) {
     if (contentText.length > MAX_INLINE_DECORATOR_LENGTH) {
         contentText = contentText.substring(0, MAX_INLINE_DECORATOR_LENGTH) + '...';
     }
@@ -113,20 +121,20 @@ function replaceWsWithNoBreakWs(str) {
     return str.replace(/[ \t]/g, noBreakWhitespace);
 }
 function createInlineValueDecorationsInsideRange(expressions, ranges, model, wordToLineNumbersMap) {
-    const nameValueMap = ( (new Map()));
+    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()));
+    const lineToNamesMap = ( new Map());
     nameValueMap.forEach((_value, name) => {
         const lineNumbers = wordToLineNumbersMap.get(name);
         if (lineNumbers) {
             for (const lineNumber of lineNumbers) {
-                if (( (ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber)))) {
-                    if (!( (lineToNamesMap.has(lineNumber)))) {
+                if (( ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber))) {
+                    if (!( lineToNamesMap.has(lineNumber))) {
                         lineToNamesMap.set(lineNumber, []);
                     }
                     if (lineToNamesMap.get(lineNumber).indexOf(name) === -1) {
@@ -136,15 +144,13 @@ function createInlineValueDecorationsInsideRange(expressions, ranges, model, wor
             }
         }
     });
-    return (
-         ([...lineToNamesMap].map(([line, names]) => ({
-            line,
-            variables: ( (names.sort((first, second) => {
-                const content = model.getLineContent(line);
-                return content.indexOf(first) - content.indexOf(second);
-            }).map(name => ({ name, value: nameValueMap.get(name) }))))
-        })))
-    );
+    return ( [...lineToNamesMap].map(([line, names]) => ({
+        line,
+        variables: ( names.sort((first, second) => {
+            const content = model.getLineContent(line);
+            return content.indexOf(first) - content.indexOf(second);
+        }).map(name => ({ name, value: nameValueMap.get(name) })))
+    })));
 }
 function getWordToLineNumbersMap(model, lineNumber, result) {
     const lineLength = model.getLineLength(lineNumber);
@@ -156,7 +162,7 @@ function getWordToLineNumbersMap(model, lineNumber, result) {
     const lineTokens = model.tokenization.getLineTokens(lineNumber);
     for (let tokenIndex = 0, tokenCount = lineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {
         const tokenType = lineTokens.getStandardTokenType(tokenIndex);
-        if (tokenType === 0 ) {
+        if (tokenType === StandardTokenType.Other) {
             DEFAULT_WORD_REGEXP.lastIndex = 0;
             const tokenStartOffset = lineTokens.getStartOffset(tokenIndex);
             const tokenEndOffset = lineTokens.getEndOffset(tokenIndex);
@@ -164,7 +170,7 @@ function getWordToLineNumbersMap(model, lineNumber, result) {
             const wordMatch = DEFAULT_WORD_REGEXP.exec(tokenStr);
             if (wordMatch) {
                 const word = wordMatch[0];
-                if (!( (result.has(word)))) {
+                if (!( result.has(word))) {
                     result.set(word, []);
                 }
                 result.get(word).push(lineNumber);
@@ -184,11 +190,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.languageFeaturesService = languageFeaturesService;
         this.mouseDown = false;
         this.gutterIsHovered = false;
-        this.altListener = ( (new MutableDisposable()));
+        this.altListener = ( new MutableDisposable());
         this.altPressed = false;
         this.oldDecorations = this.editor.createDecorationsCollection();
-        this.displayedStore = ( (new DisposableStore()));
-        this.defaultHoverLockout = ( (new MutableDisposable()));
+        this.displayedStore = ( new DisposableStore());
+        this.defaultHoverLockout = ( new MutableDisposable());
         this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
         this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
         this.toDispose = [this.defaultHoverLockout, this.altListener, this.displayedStore];
@@ -229,7 +235,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose.push(this.editor.onDidScrollChange(() => {
             this.hideHoverWidget();
             const model = this.editor.getModel();
-            if (model && ( (this.languageFeaturesService.inlineValuesProvider.has(model)))) {
+            if (model && ( this.languageFeaturesService.inlineValuesProvider.has(model))) {
                 this.updateInlineValuesScheduler.schedule();
             }
         }));
@@ -239,7 +245,7 @@ let DebugEditorContribution = class DebugEditorContribution {
             }
         }));
         this.toDispose.push(this.debugService.onDidChangeState((state) => {
-            if (state !== 2 ) {
+            if (state !== State.Stopped) {
                 this.toggleExceptionWidget();
             }
         }));
@@ -268,8 +274,8 @@ let DebugEditorContribution = class DebugEditorContribution {
         }
         const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
         this.altListener.value = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
-            const standardKeyboardEvent = ( (new StandardKeyboardEvent(keydownEvent)));
-            if (standardKeyboardEvent.keyCode === 6 ) {
+            const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
+            if (standardKeyboardEvent.keyCode === KeyCode.Alt) {
                 this.altPressed = true;
                 const debugHoverWasVisible = this.hoverWidget.isVisible();
                 this.hoverWidget.hide();
@@ -277,13 +283,13 @@ 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)) {
-                        standardKeyboardEvent = ( (new StandardKeyboardEvent(keyupEvent)));
+                        standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
                     }
-                    if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
+                    if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === KeyCode.Alt) {
                         this.altPressed = false;
                         this.preventDefaultEditorHover();
                         listener.dispose();
@@ -299,7 +305,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         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, mouseEvent);
-            if (result === 1 ) {
+            if (result === ShowDebugHoverResult.NOT_AVAILABLE) {
                 this.showEditorHover(position, focus);
             }
         }
@@ -324,9 +330,9 @@ let DebugEditorContribution = class DebugEditorContribution {
     }
     showEditorHover(position, focus) {
         const hoverController = this.editor.getContribution(ContentHoverController.ID);
-        const range = ( (new Range(position.lineNumber, position.column, position.lineNumber, position.column)));
+        const range = ( new Range(position.lineNumber, position.column, position.lineNumber, position.column));
         this.defaultHoverLockout.clear();
-        hoverController?.showContentHover(range, 1 , 0 , focus);
+        hoverController?.showContentHover(range, HoverStartMode.Immediate, HoverStartSource.Mouse, focus);
     }
     async onFocusStackFrame(sf) {
         const model = this.editor.getModel();
@@ -347,11 +353,11 @@ let DebugEditorContribution = class DebugEditorContribution {
         return baseDelay * delayFactor;
     }
     get showHoverScheduler() {
-        const scheduler = ( (new RunOnceScheduler(() => {
+        const scheduler = ( new RunOnceScheduler(() => {
             if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition.position, false, this.hoverPosition.event);
             }
-        }, this.hoverDelay)));
+        }, this.hoverDelay));
         this.toDispose.push(scheduler);
         return scheduler;
     }
@@ -364,19 +370,19 @@ let DebugEditorContribution = class DebugEditorContribution {
     }
     onEditorMouseDown(mouseEvent) {
         this.mouseDown = true;
-        if (mouseEvent.target.type === 9  && mouseEvent.target.detail === DebugHoverWidget.ID) {
+        if (mouseEvent.target.type === MouseTargetType.CONTENT_WIDGET && mouseEvent.target.detail === DebugHoverWidget.ID) {
             return;
         }
         this.hideHoverWidget();
     }
     onEditorMouseMove(mouseEvent) {
-        if (this.debugService.state !== 2 ) {
+        if (this.debugService.state !== State.Stopped) {
             return;
         }
         const target = mouseEvent.target;
         const stopKey = isMacintosh ? 'metaKey' : 'ctrlKey';
         if (!this.altPressed) {
-            if (target.type === 2 ) {
+            if (target.type === MouseTargetType.GUTTER_GLYPH_MARGIN) {
                 this.defaultHoverLockout.clear();
                 this.gutterIsHovered = true;
             }
@@ -385,13 +391,14 @@ let DebugEditorContribution = class DebugEditorContribution {
                 this.updateHoverConfiguration();
             }
         }
-        if (target.type === 9  && target.detail === DebugHoverWidget.ID && !mouseEvent.event[stopKey]) {
+        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) {
+            if (sticky || this.hoverWidget.isShowingComplexValue || mouseEvent.event[stopKey]) {
                 return;
             }
         }
-        if (target.type === 6 ) {
+        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.preventDefaultEditorHover();
@@ -403,8 +410,8 @@ let DebugEditorContribution = class DebugEditorContribution {
         }
     }
     onKeyDown(e) {
-        const stopKey = isMacintosh ? 57  : 5 ;
-        if (e.keyCode !== stopKey && e.keyCode !== 6 ) {
+        const stopKey = isMacintosh ? KeyCode.Meta : KeyCode.Ctrl;
+        if (e.keyCode !== stopKey && e.keyCode !== KeyCode.Alt) {
             this.hideHoverWidget();
         }
     }
@@ -491,12 +498,12 @@ let DebugEditorContribution = class DebugEditorContribution {
                 setProperty(model.getValue(), ['launch'], { 'configurations': [] }, { tabSize, insertSpaces, eol })[0];
             const startPosition = model.getPositionAt(edit.offset);
             const lineNumber = startPosition.lineNumber;
-            const range = ( (new Range(
+            const range = ( new Range(
                 lineNumber,
                 startPosition.column,
                 lineNumber,
                 model.getLineMaxColumn(lineNumber)
-            )));
+            ));
             model.pushEditOperations(null, [EditOperation.replace(range, edit.content)], () => null);
             getConfigurationPosition();
         }
@@ -516,29 +523,25 @@ let DebugEditorContribution = class DebugEditorContribution {
         await this.commandService.executeCommand('editor.action.triggerSuggest');
     }
     get removeInlineValuesScheduler() {
-        return (
-             (new RunOnceScheduler(() => {
-                this.displayedStore.clear();
-                this.oldDecorations.clear();
-            }, 100))
-        );
+        return ( new RunOnceScheduler(() => {
+            this.displayedStore.clear();
+            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
-            ))
-        );
+        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()))) {
+        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();
             }
@@ -548,9 +551,9 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.displayedStore.clear();
         const viewRanges = this.editor.getVisibleRangesPlusViewportAboveBelow();
         let allDecorations;
-        const cts = ( (new CancellationTokenSource()));
+        const cts = ( new CancellationTokenSource());
         this.displayedStore.add(toDisposable(() => cts.dispose(true)));
-        if (( (this.languageFeaturesService.inlineValuesProvider.has(model)))) {
+        if (( this.languageFeaturesService.inlineValuesProvider.has(model))) {
             const findVariable = async (_key, caseSensitiveLookup) => {
                 const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
                 const key = caseSensitiveLookup ? _key : _key.toLowerCase();
@@ -565,17 +568,17 @@ let DebugEditorContribution = class DebugEditorContribution {
             };
             const ctx = {
                 frameId: stackFrame.frameId,
-                stoppedLocation: ( (new Range(
+                stoppedLocation: ( new Range(
                     stackFrame.range.startLineNumber,
                     stackFrame.range.startColumn + 1,
                     stackFrame.range.endLineNumber,
                     stackFrame.range.endColumn + 1
-                )))
+                ))
             };
             const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
             allDecorations = [];
-            const lineDecorations = ( (new Map()));
-            const promises = providers.flatMap(provider => ( (viewRanges.map(
+            const lineDecorations = ( new Map());
+            const promises = providers.flatMap(provider => ( viewRanges.map(
                 range => Promise.resolve(provider.provideInlineValues(model, range, ctx, cts.token)).then(async (result) => {
                     if (result) {
                         for (const iv of result) {
@@ -603,7 +606,7 @@ let DebugEditorContribution = class DebugEditorContribution {
                                         expr = lineContent.substring(iv.range.startColumn - 1, iv.range.endColumn - 1);
                                     }
                                     if (expr) {
-                                        const expression = ( (new Expression(expr)));
+                                        const expression = ( new Expression(expr));
                                         await expression.evaluate(stackFrame.thread.session, stackFrame, 'watch', true);
                                         if (expression.available) {
                                             text = format(var_value_format, expr, expression.value);
@@ -619,8 +622,8 @@ let DebugEditorContribution = class DebugEditorContribution {
                                     lineSegments = [];
                                     lineDecorations.set(line, lineSegments);
                                 }
-                                if (!( (lineSegments.some(iv => iv.text === text)))) {
-                                    lineSegments.push(( (new InlineSegment(iv.range.startColumn, text))));
+                                if (!( lineSegments.some(iv => iv.text === text))) {
+                                    lineSegments.push(( new InlineSegment(iv.range.startColumn, text)));
                                 }
                             }
                         }
@@ -628,29 +631,29 @@ let DebugEditorContribution = class DebugEditorContribution {
                 }, 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);
+                    const text = ( segments.map(s => s.text)).join(separator);
                     allDecorations.push(...createInlineValueDecoration(line, text));
                 }
             });
         }
         else {
             const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
-            const scopesWithVariables = await Promise.all(( (scopes.map(async (scope) => ({ scope, variables: await scope.getChildren() })))));
-            const valuesPerLine = ( (new Map()));
+            const scopesWithVariables = await Promise.all(( scopes.map(async (scope) => ({ scope, variables: await scope.getChildren() }))));
+            const valuesPerLine = ( new Map());
             for (const { scope, variables } of scopesWithVariables) {
-                let scopeRange = ( (new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn)));
+                let scopeRange = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
                 if (scope.range) {
                     scopeRange = scopeRange.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
                 }
-                const ownRanges = ( (viewRanges.map(r => r.intersectRanges(scopeRange)))).filter(isDefined);
-                this._wordToLineNumbersMap ??= ( (new WordsToLineNumbersCache(model)));
+                const ownRanges = ( viewRanges.map(r => r.intersectRanges(scopeRange))).filter(isDefined);
+                this._wordToLineNumbersMap ??= ( new WordsToLineNumbersCache(model));
                 for (const range of ownRanges) {
                     this._wordToLineNumbersMap.ensureRangePopulated(range);
                 }
@@ -658,32 +661,32 @@ let DebugEditorContribution = class DebugEditorContribution {
                 for (const { line, variables } of mapped) {
                     let values = valuesPerLine.get(line);
                     if (!values) {
-                        values = ( (new Map()));
+                        values = ( new Map());
                         valuesPerLine.set(line, values);
                     }
                     for (const { name, value } of variables) {
-                        if (!( (values.has(name)))) {
+                        if (!( values.has(name))) {
                             values.set(name, value);
                         }
                     }
                 }
             }
-            allDecorations = [...valuesPerLine.entries()].flatMap(([line, values]) => createInlineValueDecoration(line, ( ([...values].map(([n, v]) => `${n} = ${v}`))).join(', ')));
+            allDecorations = [...valuesPerLine.entries()].flatMap(([line, values]) => createInlineValueDecoration(line, ( [...values].map(([n, v]) => `${n} = ${v}`)).join(', ')));
         }
         if (cts.token.isCancellationRequested) {
             return;
         }
         let preservePosition;
-        if (this.editor.getOption(135 ) !== 'off') {
+        if (this.editor.getOption(EditorOption.wordWrap) !== 'off') {
             const position = this.editor.getPosition();
-            if (position && ( (this.editor.getVisibleRanges().some(r => r.containsPosition(position))))) {
+            if (position && ( this.editor.getVisibleRanges().some(r => r.containsPosition(position)))) {
                 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), 1 );
+            this.editor.setScrollTop(this.editor.getScrollTop() - (preservePosition.top - top), ScrollType.Immediate);
         }
     }
     dispose() {
@@ -696,31 +699,31 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose = dispose(this.toDispose);
     }
 };
-DebugEditorContribution.__decorator = ( (__decorate([
+DebugEditorContribution.__decorator = ( __decorate([
     memoize
-], DebugEditorContribution.prototype, "showHoverScheduler", null)));
-DebugEditorContribution.__decorator = ( (__decorate([
+], DebugEditorContribution.prototype, "showHoverScheduler", null));
+DebugEditorContribution.__decorator = ( __decorate([
     memoize
-], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null)));
-DebugEditorContribution.__decorator = ( (__decorate([
+], 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)));
+], DebugEditorContribution.prototype, "updateInlineValuesScheduler", null));
+DebugEditorContribution = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IHostService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, ILanguageFeaturesService)),
+    ( __param(9, ILanguageFeatureDebounceService))
+], DebugEditorContribution));
 class WordsToLineNumbersCache {
     constructor(model) {
         this.model = model;
-        this.value = ( (new Map()));
-        this.intervals = ( (new Uint8Array(Math.ceil(model.getLineCount() / 8))));
+        this.value = ( new Map());
+        this.intervals = ( new Uint8Array(Math.ceil(model.getLineCount() / 8)));
     }
     ensureRangePopulated(range) {
         for (let lineNumber = range.startLineNumber; lineNumber <= range.endLineNumber; lineNumber++) {
@@ -746,9 +749,9 @@ CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor,
     const range = Range.lift(iRange);
     const { inlineValuesProvider } = accessor.get(ILanguageFeaturesService);
     const providers = inlineValuesProvider.ordered(model);
-    const providerResults = await Promise.all(( (providers.map(
+    const providerResults = await Promise.all(( providers.map(
         provider => provider.provideInlineValues(model, range, context, CancellationToken.None)
-    ))));
+    )));
     return providerResults.flat().filter(isDefined);
 });
 

package/vscode/src/vs/workbench/contrib/debug/browser/debugHover.d.ts

@@ -0,0 +1,65 @@
+import { IMouseEvent } from "vscode/vscode/vs/base/browser/mouseEvent";
+import { ContentWidgetPositionPreference, ICodeEditor, IContentWidget, IContentWidgetPosition } from "vscode/vscode/vs/editor/browser/editorBrowser";
+import { IDimension } from "vscode/vscode/vs/editor/common/core/dimension";
+import { Position } from "vscode/vscode/vs/editor/common/core/position";
+import { IMenuService } from "vscode/vscode/vs/platform/actions/common/actions.service";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "vscode/vscode/vs/platform/contextview/browser/contextView.service";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IExpression, IStackFrame } from "vscode/vscode/vs/workbench/contrib/debug/common/debug";
+import { IDebugService } from "vscode/vscode/vs/workbench/contrib/debug/common/debug.service";
+export declare enum ShowDebugHoverResult {
+    NOT_CHANGED = 0,
+    NOT_AVAILABLE = 1,
+    CANCELLED = 2
+}
+export declare function findExpressionInStackFrame(stackFrame: IStackFrame, namesToFind: string[]): Promise<IExpression | undefined>;
+export declare class DebugHoverWidget implements IContentWidget {
+    private editor;
+    private readonly debugService;
+    private readonly instantiationService;
+    private readonly menuService;
+    private readonly contextKeyService;
+    private readonly contextMenuService;
+    static readonly ID = "debug.hoverWidget";
+    readonly allowEditorOverflow = true;
+    private _isVisible?;
+    private safeTriangle?;
+    private showCancellationSource?;
+    private domNode;
+    private tree;
+    private showAtPosition;
+    private positionPreference;
+    private readonly highlightDecorations;
+    private complexValueContainer;
+    private complexValueTitle;
+    private valueContainer;
+    private treeContainer;
+    private toDispose;
+    private scrollbar;
+    private debugHoverComputer;
+    private expressionRenderer;
+    private expressionToRender;
+    private isUpdatingTree;
+    get isShowingComplexValue(): boolean;
+    constructor(editor: ICodeEditor, debugService: IDebugService, instantiationService: IInstantiationService, menuService: IMenuService, contextKeyService: IContextKeyService, contextMenuService: IContextMenuService);
+    private create;
+    private onContextMenu;
+    private registerListeners;
+    isHovered(): boolean;
+    isVisible(): boolean;
+    willBeVisible(): boolean;
+    getId(): string;
+    getDomNode(): HTMLElement;
+    isInSafeTriangle(x: number, y: number): boolean | undefined;
+    showAt(position: Position, focus: boolean, mouseEvent?: IMouseEvent): Promise<void | ShowDebugHoverResult>;
+    private static readonly _HOVER_HIGHLIGHT_DECORATION_OPTIONS;
+    private doShow;
+    private layoutTreeAndContainer;
+    private layoutTree;
+    beforeRender(): IDimension | null;
+    afterRender(positionPreference: ContentWidgetPositionPreference | null): void;
+    hide(): void;
+    getPosition(): IContentWidgetPosition | null;
+    dispose(): void;
+}