@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.6

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

@@ -1,522 +0,0 @@
-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/debugViewlet.js

@@ -1,166 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import "../../../../../../assets/debugViewlet.css";
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { createActionViewItem } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { registerAction2, 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, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IContextMenuService, IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { ViewsSubMenu, ViewPaneContainer } from '../../../browser/parts/views/viewPaneContainer.js';
-import { IViewsService, IViewDescriptorService } from '../../../common/views.js';
-import { StartDebugActionViewItem, FocusSessionActionViewItem } from './debugActionViewItems.js';
-import { DEBUG_START_COMMAND_ID, FOCUS_SESSION_ID, STOP_ID, DISCONNECT_ID } from './debugCommands.js';
-import { createDisconnectMenuItemAction } from './debugToolBar.js';
-import { WelcomeView } from './welcomeView.js';
-import { REPL_VIEW_ID, VIEWLET_ID, CONTEXT_DEBUG_UX_KEY, BREAKPOINTS_VIEW_ID, IDebugService } from '../common/debug.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-let DebugViewPaneContainer = class DebugViewPaneContainer extends ViewPaneContainer {
-    constructor(layoutService, telemetryService, progressService, debugService, instantiationService, contextService, storageService, themeService, contextMenuService, extensionService, configurationService, contextViewService, contextKeyService, viewDescriptorService) {
-        super(VIEWLET_ID, { mergeViewWithContainerWhenSingleView: true }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService);
-        this.progressService = progressService;
-        this.debugService = debugService;
-        this.contextViewService = contextViewService;
-        this.contextKeyService = contextKeyService;
-        this.paneListeners = ( new Map());
-        this.stopActionViewItemDisposables = this._register(( new DisposableStore()));
-        this._register(this.debugService.onDidChangeState(state => this.onDebugServiceStateChange(state)));
-        this._register(this.contextKeyService.onDidChangeContext(e => {
-            if (e.affectsSome(( new Set([CONTEXT_DEBUG_UX_KEY])))) {
-                this.updateTitleArea();
-            }
-        }));
-        this._register(this.contextService.onDidChangeWorkbenchState(() => this.updateTitleArea()));
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('debug.toolBarLocation')) {
-                this.updateTitleArea();
-            }
-        }));
-    }
-    create(parent) {
-        super.create(parent);
-        parent.classList.add('debug-viewlet');
-    }
-    focus() {
-        super.focus();
-        if (this.startDebugActionViewItem) {
-            this.startDebugActionViewItem.focus();
-        }
-        else {
-            this.focusView(WelcomeView.ID);
-        }
-    }
-    getActionViewItem(action) {
-        if (action.id === DEBUG_START_COMMAND_ID) {
-            this.startDebugActionViewItem = this.instantiationService.createInstance(StartDebugActionViewItem, null, action);
-            return this.startDebugActionViewItem;
-        }
-        if (action.id === FOCUS_SESSION_ID) {
-            return ( new FocusSessionActionViewItem(
-                action,
-                undefined,
-                this.debugService,
-                this.contextViewService,
-                this.configurationService
-            ));
-        }
-        if (action.id === STOP_ID || action.id === DISCONNECT_ID) {
-            this.stopActionViewItemDisposables.clear();
-            const item = this.instantiationService.invokeFunction(accessor => createDisconnectMenuItemAction(action, this.stopActionViewItemDisposables, accessor));
-            if (item) {
-                return item;
-            }
-        }
-        return createActionViewItem(this.instantiationService, action);
-    }
-    focusView(id) {
-        const view = this.getView(id);
-        if (view) {
-            view.focus();
-        }
-    }
-    onDebugServiceStateChange(state) {
-        if (this.progressResolve) {
-            this.progressResolve();
-            this.progressResolve = undefined;
-        }
-        if (state === 1 ) {
-            this.progressService.withProgress({ location: VIEWLET_ID, }, _progress => {
-                return ( new Promise(resolve => this.progressResolve = resolve));
-            });
-        }
-    }
-    addPanes(panes) {
-        super.addPanes(panes);
-        for (const { pane: pane } of panes) {
-            if (pane.id === BREAKPOINTS_VIEW_ID) {
-                this.breakpointView = pane;
-                this.updateBreakpointsMaxSize();
-            }
-            else {
-                this.paneListeners.set(pane.id, pane.onDidChange(() => this.updateBreakpointsMaxSize()));
-            }
-        }
-    }
-    removePanes(panes) {
-        super.removePanes(panes);
-        for (const pane of panes) {
-            dispose(this.paneListeners.get(pane.id));
-            this.paneListeners.delete(pane.id);
-        }
-    }
-    updateBreakpointsMaxSize() {
-        if (this.breakpointView) {
-            const allOtherCollapsed = this.panes.every(view => !view.isExpanded() || view === this.breakpointView);
-            this.breakpointView.maximumBodySize = allOtherCollapsed ? Number.POSITIVE_INFINITY : this.breakpointView.minimumBodySize;
-        }
-    }
-};
-DebugViewPaneContainer = ( __decorate([
-    ( __param(0, IWorkbenchLayoutService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IProgressService)),
-    ( __param(3, IDebugService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IWorkspaceContextService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IThemeService)),
-    ( __param(8, IContextMenuService)),
-    ( __param(9, IExtensionService)),
-    ( __param(10, IConfigurationService)),
-    ( __param(11, IContextViewService)),
-    ( __param(12, IContextKeyService)),
-    ( __param(13, IViewDescriptorService))
-], DebugViewPaneContainer));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'debug.toggleReplIgnoreFocus',
-            title: ( nls.localize('debugPanel', "Debug Console")),
-            toggled: ( ContextKeyExpr.has(`view.${REPL_VIEW_ID}.visible`)),
-            menu: [{
-                    id: ViewsSubMenu,
-                    group: '3_toggleRepl',
-                    order: 30,
-                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('viewContainer', VIEWLET_ID))))
-                }]
-        });
-    }
-    async run(accessor) {
-        const viewsService = accessor.get(IViewsService);
-        if (viewsService.isViewVisible(REPL_VIEW_ID)) {
-            viewsService.closeView(REPL_VIEW_ID);
-        }
-        else {
-            await viewsService.openView(REPL_VIEW_ID);
-        }
-    }
-});
-export { DebugViewPaneContainer };