@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -0,0 +1,522 @@
+import { getDomNodePagePosition } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { registerEditorAction, EditorAction, EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { MessageController } from 'monaco-editor/esm/vs/editor/contrib/message/browser/messageController.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { PanelFocusContext } from '../../../common/contextkeys.js';
+import { IViewsService } from '../../../common/views.js';
+import { openBreakpointSource } from './breakpointsView.js';
+import { CONTEXT_DEBUGGERS_AVAILABLE, IDebugService, BREAKPOINT_EDITOR_CONTRIBUTION_ID, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE, CONTEXT_IN_DEBUG_MODE, CONTEXT_DEBUG_STATE, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST, CONTEXT_CALLSTACK_ITEM_TYPE, REPL_VIEW_ID, WATCH_VIEW_ID, EDITOR_CONTRIBUTION_ID, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_EXCEPTION_WIDGET_VISIBLE } from '../common/debug.js';
+import { getEvaluatableExpressionAtPosition } from '../common/debugUtils.js';
+import { DisassemblyViewInput } from '../common/disassemblyViewInput.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+class ToggleBreakpointAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.toggleBreakpoint',
+            label: ( nls.localize('toggleBreakpointAction', "Debug: Toggle Breakpoint")),
+            alias: 'Debug: Toggle Breakpoint',
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 67 ,
+                weight: 100
+            },
+            menuOpts: {
+                when: CONTEXT_DEBUGGERS_AVAILABLE,
+                title: ( nls.localize(
+                    { key: 'miToggleBreakpoint', comment: ['&& denotes a mnemonic'] },
+                    "Toggle &&Breakpoint"
+                )),
+                menuId: MenuId.MenubarDebugMenu,
+                group: '4_new_breakpoint',
+                order: 1
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (editor.hasModel()) {
+            const debugService = accessor.get(IDebugService);
+            const modelUri = editor.getModel().uri;
+            const canSet = debugService.canSetBreakpointsIn(editor.getModel());
+            const lineNumbers = [...( new Set(( editor.getSelections().map(s => s.getPosition().lineNumber))))];
+            await Promise.all(( lineNumbers.map(async (line) => {
+                const bps = debugService.getModel().getBreakpoints({ lineNumber: line, uri: modelUri });
+                if (bps.length) {
+                    await Promise.all(( bps.map(bp => debugService.removeBreakpoints(bp.getId()))));
+                }
+                else if (canSet) {
+                    await debugService.addBreakpoints(modelUri, [{ lineNumber: line }]);
+                }
+            })));
+        }
+    }
+}
+class ConditionalBreakpointAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.conditionalBreakpoint',
+            label: ( nls.localize(
+                'conditionalBreakpointEditorAction',
+                "Debug: Add Conditional Breakpoint..."
+            )),
+            alias: 'Debug: Add Conditional Breakpoint...',
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            menuOpts: {
+                menuId: MenuId.MenubarNewBreakpointMenu,
+                title: ( nls.localize(
+                    { key: 'miConditionalBreakpoint', comment: ['&& denotes a mnemonic'] },
+                    "&&Conditional Breakpoint..."
+                )),
+                group: '1_breakpoints',
+                order: 1,
+                when: CONTEXT_DEBUGGERS_AVAILABLE
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const position = editor.getPosition();
+        if (position && editor.hasModel() && debugService.canSetBreakpointsIn(editor.getModel())) {
+            editor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(position.lineNumber, undefined, 0 );
+        }
+    }
+}
+class LogPointAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.addLogPoint',
+            label: ( nls.localize('logPointEditorAction', "Debug: Add Logpoint...")),
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            alias: 'Debug: Add Logpoint...',
+            menuOpts: [
+                {
+                    menuId: MenuId.MenubarNewBreakpointMenu,
+                    title: ( nls.localize({ key: 'miLogPoint', comment: ['&& denotes a mnemonic'] }, "&&Logpoint...")),
+                    group: '1_breakpoints',
+                    order: 4,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE,
+                }
+            ]
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const position = editor.getPosition();
+        if (position && editor.hasModel() && debugService.canSetBreakpointsIn(editor.getModel())) {
+            editor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(position.lineNumber, position.column, 2 );
+        }
+    }
+}
+class EditBreakpointAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.editBreakpoint',
+            label: ( nls.localize('EditBreakpointEditorAction', "Debug: Edit Breakpoint")),
+            alias: 'Debug: Edit Existing Breakpoint',
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            menuOpts: {
+                menuId: MenuId.MenubarNewBreakpointMenu,
+                title: ( nls.localize(
+                    { key: 'miEditBreakpoint', comment: ['&& denotes a mnemonic'] },
+                    "&&Edit Breakpoint"
+                )),
+                group: '1_breakpoints',
+                order: 1,
+                when: CONTEXT_DEBUGGERS_AVAILABLE
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const position = editor.getPosition();
+        const debugModel = debugService.getModel();
+        if (!(editor.hasModel() && position)) {
+            return;
+        }
+        const lineBreakpoints = debugModel.getBreakpoints({ lineNumber: position.lineNumber });
+        if (lineBreakpoints.length === 0) {
+            return;
+        }
+        const breakpointDistances = ( lineBreakpoints.map(b => {
+            if (!b.column) {
+                return position.column;
+            }
+            return Math.abs(b.column - position.column);
+        }));
+        const closestBreakpointIndex = breakpointDistances.indexOf(Math.min(...breakpointDistances));
+        const closestBreakpoint = lineBreakpoints[closestBreakpointIndex];
+        editor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(closestBreakpoint.lineNumber, closestBreakpoint.column);
+    }
+}
+class OpenDisassemblyViewAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: OpenDisassemblyViewAction.ID,
+            title: {
+                value: ( nls.localize('openDisassemblyView', "Open Disassembly View")),
+                original: 'Open Disassembly View',
+                mnemonicTitle: ( nls.localize(
+                    { key: 'miDisassemblyView', comment: ['&& denotes a mnemonic'] },
+                    "&&DisassemblyView"
+                ))
+            },
+            precondition: CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE,
+            menu: [
+                {
+                    id: MenuId.EditorContext,
+                    group: 'debug',
+                    order: 5,
+                    when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ( PanelFocusContext.toNegated()), ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), EditorContextKeys.editorTextFocus, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_LANGUAGE_SUPPORTS_DISASSEMBLE_REQUEST))
+                },
+                {
+                    id: MenuId.DebugCallStackContext,
+                    group: 'z_commands',
+                    order: 50,
+                    when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), ( CONTEXT_CALLSTACK_ITEM_TYPE.isEqualTo('stackFrame')), CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED))
+                },
+                {
+                    id: MenuId.CommandPalette,
+                    when: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED))
+                }
+            ]
+        });
+    }
+    runEditorCommand(accessor, editor, ...args) {
+        if (editor.hasModel()) {
+            const editorService = accessor.get(IEditorService);
+            editorService.openEditor(DisassemblyViewInput.instance, { pinned: true });
+        }
+    }
+}
+OpenDisassemblyViewAction.ID = 'editor.debug.action.openDisassemblyView';
+class ToggleDisassemblyViewSourceCodeAction extends Action2 {
+    constructor() {
+        super({
+            id: ToggleDisassemblyViewSourceCodeAction.ID,
+            title: {
+                value: ( nls.localize(
+                    'toggleDisassemblyViewSourceCode',
+                    "Toggle Source Code in Disassembly View"
+                )),
+                original: 'Toggle Source Code in Disassembly View',
+                mnemonicTitle: ( nls.localize(
+                    { key: 'mitogglesource', comment: ['&& denotes a mnemonic'] },
+                    "&&ToggleSource"
+                ))
+            },
+            f1: true,
+        });
+    }
+    run(accessor, editor, ...args) {
+        const configService = accessor.get(IConfigurationService);
+        if (configService) {
+            const value = configService.getValue('debug').disassemblyView.showSourceCode;
+            configService.updateValue(ToggleDisassemblyViewSourceCodeAction.configID, !value);
+        }
+    }
+}
+ToggleDisassemblyViewSourceCodeAction.ID = 'debug.action.toggleDisassemblyViewSourceCode';
+ToggleDisassemblyViewSourceCodeAction.configID = 'debug.disassemblyView.showSourceCode';
+class RunToCursorAction extends EditorAction {
+    constructor() {
+        super({
+            id: RunToCursorAction.ID,
+            label: RunToCursorAction.LABEL,
+            alias: 'Debug: Run to Cursor',
+            precondition: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( PanelFocusContext.toNegated()), EditorContextKeys.editorTextFocus)),
+            contextMenuOpts: {
+                group: 'debug',
+                order: 2
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const position = editor.getPosition();
+        if (!(editor.hasModel() && position)) {
+            return;
+        }
+        const uri = editor.getModel().uri;
+        const debugService = accessor.get(IDebugService);
+        const viewModel = debugService.getViewModel();
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        let column = undefined;
+        const focusedStackFrame = viewModel.focusedStackFrame;
+        if (focusedStackFrame && uriIdentityService.extUri.isEqual(focusedStackFrame.source.uri, uri) && focusedStackFrame.range.startLineNumber === position.lineNumber) {
+            column = position.column;
+        }
+        await debugService.runTo(uri, position.lineNumber, column);
+    }
+}
+RunToCursorAction.ID = 'editor.debug.action.runToCursor';
+RunToCursorAction.LABEL = ( nls.localize('runToCursor', "Run to Cursor"));
+class SelectionToReplAction extends EditorAction {
+    constructor() {
+        super({
+            id: SelectionToReplAction.ID,
+            label: SelectionToReplAction.LABEL,
+            alias: 'Debug: Evaluate in Console',
+            precondition: ( ContextKeyExpr.and(CONTEXT_IN_DEBUG_MODE, EditorContextKeys.editorTextFocus)),
+            contextMenuOpts: {
+                group: 'debug',
+                order: 0
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const viewsService = accessor.get(IViewsService);
+        const viewModel = debugService.getViewModel();
+        const session = viewModel.focusedSession;
+        if (!editor.hasModel() || !session) {
+            return;
+        }
+        const selection = editor.getSelection();
+        let text;
+        if (selection.isEmpty()) {
+            text = editor.getModel().getLineContent(selection.selectionStartLineNumber).trim();
+        }
+        else {
+            text = editor.getModel().getValueInRange(selection);
+        }
+        await session.addReplExpression(viewModel.focusedStackFrame, text);
+        await viewsService.openView(REPL_VIEW_ID, false);
+    }
+}
+SelectionToReplAction.ID = 'editor.debug.action.selectionToRepl';
+SelectionToReplAction.LABEL = ( nls.localize('evaluateInDebugConsole', "Evaluate in Debug Console"));
+class SelectionToWatchExpressionsAction extends EditorAction {
+    constructor() {
+        super({
+            id: SelectionToWatchExpressionsAction.ID,
+            label: SelectionToWatchExpressionsAction.LABEL,
+            alias: 'Debug: Add to Watch',
+            precondition: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus)),
+            contextMenuOpts: {
+                group: 'debug',
+                order: 1
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const viewsService = accessor.get(IViewsService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        if (!editor.hasModel()) {
+            return;
+        }
+        let expression = undefined;
+        const model = editor.getModel();
+        const selection = editor.getSelection();
+        if (!selection.isEmpty()) {
+            expression = model.getValueInRange(selection);
+        }
+        else {
+            const position = editor.getPosition();
+            const evaluatableExpression = await getEvaluatableExpressionAtPosition(languageFeaturesService, model, position);
+            if (!evaluatableExpression) {
+                return;
+            }
+            expression = evaluatableExpression.matchingExpression;
+        }
+        if (!expression) {
+            return;
+        }
+        await viewsService.openView(WATCH_VIEW_ID);
+        debugService.addWatchExpression(expression);
+    }
+}
+SelectionToWatchExpressionsAction.ID = 'editor.debug.action.selectionToWatch';
+SelectionToWatchExpressionsAction.LABEL = ( nls.localize('addToWatch', "Add to Watch"));
+class ShowDebugHoverAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.showDebugHover',
+            label: ( nls.localize('showDebugHover', "Debug: Show Hover")),
+            alias: 'Debug: Show Hover',
+            precondition: CONTEXT_IN_DEBUG_MODE,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 39 ),
+                weight: 100
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const position = editor.getPosition();
+        if (!position || !editor.hasModel()) {
+            return;
+        }
+        return editor.getContribution(EDITOR_CONTRIBUTION_ID)?.showHover(position, true);
+    }
+}
+const NO_TARGETS_MESSAGE = ( nls.localize(
+    'editor.debug.action.stepIntoTargets.notAvailable',
+    "Step targets are not available here"
+));
+class StepIntoTargetsAction extends EditorAction {
+    constructor() {
+        super({
+            id: StepIntoTargetsAction.ID,
+            label: StepIntoTargetsAction.LABEL,
+            alias: 'Debug: Step Into Target',
+            precondition: ( ContextKeyExpr.and(CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_IN_DEBUG_MODE, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')), EditorContextKeys.editorTextFocus)),
+            contextMenuOpts: {
+                group: 'debug',
+                order: 1.5
+            }
+        });
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const contextMenuService = accessor.get(IContextMenuService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        const session = debugService.getViewModel().focusedSession;
+        const frame = debugService.getViewModel().focusedStackFrame;
+        const selection = editor.getSelection();
+        const targetPosition = selection?.getPosition() || (frame && { lineNumber: frame.range.startLineNumber, column: frame.range.startColumn });
+        if (!session || !frame || !editor.hasModel() || !uriIdentityService.extUri.isEqual(editor.getModel().uri, frame.source.uri)) {
+            if (targetPosition) {
+                MessageController.get(editor)?.showMessage(NO_TARGETS_MESSAGE, targetPosition);
+            }
+            return;
+        }
+        const targets = await session.stepInTargets(frame.frameId);
+        if (!targets?.length) {
+            MessageController.get(editor)?.showMessage(NO_TARGETS_MESSAGE, targetPosition);
+            return;
+        }
+        if (selection) {
+            const positionalTargets = [];
+            for (const target of targets) {
+                if (target.line) {
+                    positionalTargets.push({
+                        start: ( new Position(target.line, target.column || 1)),
+                        end: target.endLine ? ( new Position(target.endLine, target.endColumn || 1)) : undefined,
+                        target
+                    });
+                }
+            }
+            positionalTargets.sort((a, b) => b.start.lineNumber - a.start.lineNumber || b.start.column - a.start.column);
+            const needle = selection.getPosition();
+            const best = positionalTargets.find(t => t.end && needle.isBefore(t.end) && t.start.isBeforeOrEqual(needle)) || positionalTargets.find(t => t.end === undefined && t.start.isBeforeOrEqual(needle));
+            if (best) {
+                session.stepIn(frame.thread.threadId, best.target.id);
+                return;
+            }
+        }
+        editor.revealLineInCenterIfOutsideViewport(frame.range.startLineNumber);
+        const cursorCoords = editor.getScrolledVisiblePosition(targetPosition);
+        const editorCoords = getDomNodePagePosition(editor.getDomNode());
+        const x = editorCoords.left + cursorCoords.left;
+        const y = editorCoords.top + cursorCoords.top + cursorCoords.height;
+        contextMenuService.showContextMenu({
+            getAnchor: () => ({ x, y }),
+            getActions: () => {
+                return ( targets.map(t => ( new Action(
+                    `stepIntoTarget:${t.id}`,
+                    t.label,
+                    undefined,
+                    true,
+                    () => session.stepIn(frame.thread.threadId, t.id)
+                ))));
+            }
+        });
+    }
+}
+StepIntoTargetsAction.ID = 'editor.debug.action.stepIntoTargets';
+StepIntoTargetsAction.LABEL = ( nls.localize(
+    { key: 'stepIntoTargets', comment: ['Step Into Targets lets the user step into an exact function he or she is interested in.'] },
+    "Step Into Target"
+));
+class GoToBreakpointAction extends EditorAction {
+    constructor(isNext, opts) {
+        super(opts);
+        this.isNext = isNext;
+    }
+    async run(accessor, editor) {
+        const debugService = accessor.get(IDebugService);
+        const editorService = accessor.get(IEditorService);
+        const uriIdentityService = accessor.get(IUriIdentityService);
+        if (editor.hasModel()) {
+            const currentUri = editor.getModel().uri;
+            const currentLine = editor.getPosition().lineNumber;
+            const allEnabledBreakpoints = debugService.getModel().getBreakpoints({ enabledOnly: true });
+            let moveBreakpoint = this.isNext
+                ? allEnabledBreakpoints.filter(bp => uriIdentityService.extUri.isEqual(bp.uri, currentUri) && bp.lineNumber > currentLine).shift()
+                : allEnabledBreakpoints.filter(bp => uriIdentityService.extUri.isEqual(bp.uri, currentUri) && bp.lineNumber < currentLine).pop();
+            if (!moveBreakpoint) {
+                moveBreakpoint =
+                    this.isNext
+                        ? allEnabledBreakpoints.filter(bp => ( bp.uri.toString()) > ( currentUri.toString())).shift()
+                        : allEnabledBreakpoints.filter(bp => ( bp.uri.toString()) < ( currentUri.toString())).pop();
+            }
+            if (!moveBreakpoint && allEnabledBreakpoints.length) {
+                moveBreakpoint = this.isNext ? allEnabledBreakpoints[0] : allEnabledBreakpoints[allEnabledBreakpoints.length - 1];
+            }
+            if (moveBreakpoint) {
+                return openBreakpointSource(moveBreakpoint, false, true, false, debugService, editorService);
+            }
+        }
+    }
+}
+class GoToNextBreakpointAction extends GoToBreakpointAction {
+    constructor() {
+        super(true, {
+            id: 'editor.debug.action.goToNextBreakpoint',
+            label: ( nls.localize('goToNextBreakpoint', "Debug: Go to Next Breakpoint")),
+            alias: 'Debug: Go to Next Breakpoint',
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE
+        });
+    }
+}
+class GoToPreviousBreakpointAction extends GoToBreakpointAction {
+    constructor() {
+        super(false, {
+            id: 'editor.debug.action.goToPreviousBreakpoint',
+            label: ( nls.localize('goToPreviousBreakpoint', "Debug: Go to Previous Breakpoint")),
+            alias: 'Debug: Go to Previous Breakpoint',
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE
+        });
+    }
+}
+class CloseExceptionWidgetAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.debug.action.closeExceptionWidget',
+            label: ( nls.localize('closeExceptionWidget', "Close Exception Widget")),
+            alias: 'Close Exception Widget',
+            precondition: CONTEXT_EXCEPTION_WIDGET_VISIBLE,
+            kbOpts: {
+                primary: 9 ,
+                weight: 100
+            }
+        });
+    }
+    async run(_accessor, editor) {
+        const contribution = editor.getContribution(EDITOR_CONTRIBUTION_ID);
+        contribution?.closeExceptionWidget();
+    }
+}
+registerEditorAction(ToggleBreakpointAction);
+registerEditorAction(ConditionalBreakpointAction);
+registerEditorAction(LogPointAction);
+registerEditorAction(EditBreakpointAction);
+registerEditorAction(RunToCursorAction);
+registerEditorAction(StepIntoTargetsAction);
+registerEditorAction(SelectionToReplAction);
+registerEditorAction(SelectionToWatchExpressionsAction);
+registerEditorAction(ShowDebugHoverAction);
+registerEditorAction(GoToNextBreakpointAction);
+registerEditorAction(GoToPreviousBreakpointAction);
+registerEditorAction(CloseExceptionWidgetAction);
+export { RunToCursorAction, SelectionToReplAction, SelectionToWatchExpressionsAction };

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

@@ -262,14 +262,7 @@ let DebugEditorContribution = class DebugEditorContribution {
                     this.hoverWidget.hide();
                     this.enableEditorHover();
                     if (debugHoverWasVisible && this.hoverPosition) {
-                        const hoverController = this.editor.getContribution(ModesHoverController.ID);
-                        const range = ( new Range(
-                            this.hoverPosition.lineNumber,
-                            this.hoverPosition.column,
-                            this.hoverPosition.lineNumber,
-                            this.hoverPosition.column
-                        ));
-                        hoverController?.showContentHover(range, 1 , 0 , false);
+                        this.showEditorHover(this.hoverPosition, false);
                     }
                     const onKeyUp = ( new DomEmitter(document, 'keyup'));
                     const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
@@ -314,9 +307,17 @@ let DebugEditorContribution = class DebugEditorContribution {
         const sf = this.debugService.getViewModel().focusedStackFrame;
         const model = this.editor.getModel();
         if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri) && !this.altPressed) {
-            return this.hoverWidget.showAt(position, focus);
+            const result = await this.hoverWidget.showAt(position, focus);
+            if (result === 1 ) {
+                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) {

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

@@ -132,20 +132,28 @@ let DebugHoverWidget = class DebugHoverWidget {
         const session = this.debugService.getViewModel().focusedSession;
         if (!session || !this.editor.hasModel()) {
             this.hide();
-            return;
+            return 1 ;
         }
         const result = await this.debugHoverComputer.compute(position, cancellationSource.token);
-        if (this.isVisible() && !result.rangeChanged) {
-            return;
+        if (cancellationSource.token.isCancellationRequested) {
+            this.hide();
+            return 2 ;
         }
-        if (!result.range || cancellationSource.token.isCancellationRequested) {
+        if (!result.range) {
             this.hide();
-            return;
+            return 1 ;
+        }
+        if (this.isVisible() && !result.rangeChanged) {
+            return 0 ;
         }
         const expression = await this.debugHoverComputer.evaluate(session);
-        if (cancellationSource.token.isCancellationRequested || !expression || (expression instanceof Expression && !expression.available)) {
+        if (cancellationSource.token.isCancellationRequested) {
             this.hide();
-            return;
+            return 2 ;
+        }
+        if (!expression || (expression instanceof Expression && !expression.available)) {
+            this.hide();
+            return 1 ;
         }
         this.highlightDecorations.set([{
                 range: result.range,

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

@@ -1,6 +1,13 @@
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const debugConsoleViewIcon = ( registerIcon('debug-console-view-icon', Codicon.debugConsole, ( localize('debugConsoleViewIcon', 'View icon of the debug console view.'))));
+const runViewIcon = ( registerIcon('run-view-icon', Codicon.debugAlt, ( localize('runViewIcon', 'View icon of the run view.'))));
+const variablesViewIcon = ( registerIcon('variables-view-icon', Codicon.debugAlt, ( localize('variablesViewIcon', 'View icon of the variables view.'))));
+const watchViewIcon = ( registerIcon('watch-view-icon', Codicon.debugAlt, ( localize('watchViewIcon', 'View icon of the watch view.'))));
+const callStackViewIcon = ( registerIcon('callstack-view-icon', Codicon.debugAlt, ( localize('callStackViewIcon', 'View icon of the call stack view.'))));
+const breakpointsViewIcon = ( registerIcon('breakpoints-view-icon', Codicon.debugAlt, ( localize('breakpointsViewIcon', 'View icon of the breakpoints view.'))));
+const loadedScriptsViewIcon = ( registerIcon('loaded-scripts-view-icon', Codicon.debugAlt, ( localize('loadedScriptsViewIcon', 'View icon of the loaded scripts view.'))));
 const breakpoint = {
     regular: ( registerIcon('debug-breakpoint', Codicon.debugBreakpoint, ( localize('debugBreakpoint', 'Icon for breakpoints.')))),
     disabled: ( registerIcon(
@@ -120,6 +127,20 @@ const debugRun = ( registerIcon('debug-run', Codicon.run, ( localize('debugRun',
 const debugStart = ( registerIcon('debug-start', Codicon.debugStart, ( localize('debugStart', 'Icon for the debug start action.'))));
 const debugConfigure = ( registerIcon('debug-configure', Codicon.gear, ( localize('debugConfigure', 'Icon for the debug configure action.'))));
 const debugRemoveConfig = ( registerIcon('debug-remove-config', Codicon.trash, ( localize('debugRemoveConfig', 'Icon for removing debug configurations.'))));
+const callstackViewSession = ( registerIcon('callstack-view-session', Codicon.bug, ( localize(
+    'callstackViewSession',
+    'Icon for the session icon in the call stack view.'
+))));
+const debugConsoleClearAll = ( registerIcon('debug-console-clear-all', Codicon.clearAll, ( localize(
+    'debugConsoleClearAll',
+    'Icon for the clear all action in the debug console.'
+))));
+const watchExpressionsRemoveAll = ( registerIcon('watch-expressions-remove-all', Codicon.closeAll, ( localize(
+    'watchExpressionsRemoveAll',
+    'Icon for the Remove All action in the watch view.'
+))));
+const watchExpressionRemove = ( registerIcon('watch-expression-remove', Codicon.removeClose, ( localize('watchExpressionRemove', 'Icon for the Remove action in the watch view.'))));
+const watchExpressionsAdd = ( registerIcon('watch-expressions-add', Codicon.add, ( localize('watchExpressionsAdd', 'Icon for the add action in the watch view.'))));
 const watchExpressionsAddFuncBreakpoint = ( registerIcon('watch-expressions-add-function-breakpoint', Codicon.add, ( localize(
     'watchExpressionsAddFuncBreakpoint',
     'Icon for the add function breakpoint action in the watch view.'
@@ -132,4 +153,10 @@ const breakpointsActivate = ( registerIcon('breakpoints-activate', Codicon.activ
     'breakpointsActivate',
     'Icon for the activate action in the breakpoints view.'
 ))));
-export { allBreakpoints, breakpoint, breakpointsActivate, breakpointsRemoveAll, conditionalBreakpoint, dataBreakpoint, debugBreakpointHint, debugBreakpointUnsupported, debugConfigure, debugContinue, debugDisconnect, debugGripper, debugPause, debugRemoveConfig, debugRestart, debugRestartFrame, debugReverseContinue, debugRun, debugStackframe, debugStackframeFocused, debugStart, debugStepBack, debugStepInto, debugStepOut, debugStepOver, debugStop, functionBreakpoint, logBreakpoint, watchExpressionsAddFuncBreakpoint };
+const debugConsoleEvaluationInput = ( registerIcon('debug-console-evaluation-input', Codicon.arrowSmallRight, ( localize(
+    'debugConsoleEvaluationInput',
+    'Icon for the debug evaluation input marker.'
+))));
+const debugConsoleEvaluationPrompt = ( registerIcon('debug-console-evaluation-prompt', Codicon.chevronRight, ( localize('debugConsoleEvaluationPrompt', 'Icon for the debug evaluation prompt.'))));
+const debugInspectMemory = ( registerIcon('debug-inspect-memory', Codicon.fileBinary, ( localize('debugInspectMemory', 'Icon for the inspect memory action.'))));
+export { allBreakpoints, breakpoint, breakpointsActivate, breakpointsRemoveAll, breakpointsViewIcon, callStackViewIcon, callstackViewSession, conditionalBreakpoint, dataBreakpoint, debugBreakpointHint, debugBreakpointUnsupported, debugConfigure, debugConsoleClearAll, debugConsoleEvaluationInput, debugConsoleEvaluationPrompt, debugConsoleViewIcon, debugContinue, debugDisconnect, debugGripper, debugInspectMemory, debugPause, debugRemoveConfig, debugRestart, debugRestartFrame, debugReverseContinue, debugRun, debugStackframe, debugStackframeFocused, debugStart, debugStepBack, debugStepInto, debugStepOut, debugStepOver, debugStop, functionBreakpoint, loadedScriptsViewIcon, logBreakpoint, runViewIcon, variablesViewIcon, watchExpressionRemove, watchExpressionsAdd, watchExpressionsAddFuncBreakpoint, watchExpressionsRemoveAll, watchViewIcon };