@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,714 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Gesture } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.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 { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ViewAction } from '../../../browser/parts/views/viewPane.js';
+import { watchExpressionsAddFuncBreakpoint, breakpointsActivate, breakpointsRemoveAll, debugBreakpointUnsupported, logBreakpoint, conditionalBreakpoint, dataBreakpoint, functionBreakpoint, breakpoint } from './debugIcons.js';
+import { BREAKPOINTS_VIEW_ID, CONTEXT_DEBUGGERS_AVAILABLE, IDebugService, CONTEXT_BREAKPOINT_ITEM_TYPE, CONTEXT_BREAKPOINTS_EXIST, CONTEXT_IN_DEBUG_MODE, CONTEXT_BREAKPOINT_SUPPORTS_CONDITION, BREAKPOINT_EDITOR_CONTRIBUTION_ID, DEBUG_SCHEME } from '../common/debug.js';
+import { Breakpoint, FunctionBreakpoint, DataBreakpoint, InstructionBreakpoint } from '../common/debugModel.js';
+import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+const $ = dom.$;
+function createCheckbox(disposables) {
+    const checkbox = $('input');
+    checkbox.type = 'checkbox';
+    checkbox.tabIndex = -1;
+    disposables.push(Gesture.ignoreTarget(checkbox));
+    return checkbox;
+}
+const breakpointIdToActionBarDomeNode = ( new Map());
+let BreakpointsRenderer = class BreakpointsRenderer {
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    get templateId() {
+        return BreakpointsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = [];
+        data.breakpoint = dom.append(container, $('.breakpoint'));
+        data.icon = $('.icon');
+        data.checkbox = createCheckbox(data.toDispose);
+        data.toDispose.push(dom.addStandardDisposableListener(data.checkbox, 'change', (e) => {
+            this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
+        }));
+        dom.append(data.breakpoint, data.icon);
+        dom.append(data.breakpoint, data.checkbox);
+        data.name = dom.append(data.breakpoint, $('span.name'));
+        data.filePath = dom.append(data.breakpoint, $('span.file-path'));
+        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.toDispose.push(data.actionBar);
+        const lineNumberContainer = dom.append(data.breakpoint, $('.line-number-container'));
+        data.lineNumber = dom.append(lineNumberContainer, $('span.line-number.monaco-count-badge'));
+        return data;
+    }
+    renderElement(breakpoint, index, data) {
+        data.context = breakpoint;
+        data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
+        data.name.textContent = resources.basenameOrAuthority(breakpoint.uri);
+        data.lineNumber.textContent = ( breakpoint.lineNumber.toString());
+        if (breakpoint.column) {
+            data.lineNumber.textContent += `:${breakpoint.column}`;
+        }
+        data.filePath.textContent = this.labelService.getUriLabel(resources.dirname(breakpoint.uri), { relative: true });
+        data.checkbox.checked = breakpoint.enabled;
+        const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService);
+        data.icon.className = ThemeIcon.asClassName(icon);
+        data.breakpoint.title = breakpoint.message || message || '';
+        const debugActive = this.debugService.state === 3  || this.debugService.state === 2 ;
+        if (debugActive && !breakpoint.verified) {
+            data.breakpoint.classList.add('disabled');
+        }
+        const primary = [];
+        const session = this.debugService.getViewModel().focusedSession;
+        this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
+        this.breakpointItemType.set('breakpoint');
+        createAndFillInActionBarActions(this.menu, { arg: breakpoint, shouldForwardArgs: true }, { primary, secondary: [] }, 'inline');
+        data.actionBar.clear();
+        data.actionBar.push(primary, { icon: true, label: false });
+        breakpointIdToActionBarDomeNode.set(breakpoint.getId(), data.actionBar.domNode);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+BreakpointsRenderer.ID = 'breakpoints';
+BreakpointsRenderer = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, ILabelService))
+], BreakpointsRenderer));
+let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    get templateId() {
+        return FunctionBreakpointsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = [];
+        data.breakpoint = dom.append(container, $('.breakpoint'));
+        data.icon = $('.icon');
+        data.checkbox = createCheckbox(data.toDispose);
+        data.toDispose.push(dom.addStandardDisposableListener(data.checkbox, 'change', (e) => {
+            this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
+        }));
+        dom.append(data.breakpoint, data.icon);
+        dom.append(data.breakpoint, data.checkbox);
+        data.name = dom.append(data.breakpoint, $('span.name'));
+        data.condition = dom.append(data.breakpoint, $('span.condition'));
+        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.toDispose.push(data.actionBar);
+        return data;
+    }
+    renderElement(functionBreakpoint, _index, data) {
+        data.context = functionBreakpoint;
+        data.name.textContent = functionBreakpoint.name;
+        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), functionBreakpoint, this.labelService);
+        data.icon.className = ThemeIcon.asClassName(icon);
+        data.icon.title = message ? message : '';
+        data.checkbox.checked = functionBreakpoint.enabled;
+        data.breakpoint.title = message ? message : '';
+        if (functionBreakpoint.condition && functionBreakpoint.hitCondition) {
+            data.condition.textContent = ( localize(
+                'expressionAndHitCount',
+                "Expression: {0} | Hit Count: {1}",
+                functionBreakpoint.condition,
+                functionBreakpoint.hitCondition
+            ));
+        }
+        else {
+            data.condition.textContent = functionBreakpoint.condition || functionBreakpoint.hitCondition || '';
+        }
+        const session = this.debugService.getViewModel().focusedSession;
+        data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsFunctionBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
+        if (session && !session.capabilities.supportsFunctionBreakpoints) {
+            data.breakpoint.title = ( localize(
+                'functionBreakpointsNotSupported',
+                "Function breakpoints are not supported by this debug type"
+            ));
+        }
+        const primary = [];
+        this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
+        this.breakpointItemType.set('functionBreakpoint');
+        createAndFillInActionBarActions(this.menu, { arg: functionBreakpoint, shouldForwardArgs: true }, { primary, secondary: [] }, 'inline');
+        data.actionBar.clear();
+        data.actionBar.push(primary, { icon: true, label: false });
+        breakpointIdToActionBarDomeNode.set(functionBreakpoint.getId(), data.actionBar.domNode);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+FunctionBreakpointsRenderer.ID = 'functionbreakpoints';
+FunctionBreakpointsRenderer = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, ILabelService))
+], FunctionBreakpointsRenderer));
+let DataBreakpointsRenderer = class DataBreakpointsRenderer {
+    constructor(debugService, labelService) {
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    get templateId() {
+        return DataBreakpointsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.breakpoint = dom.append(container, $('.breakpoint'));
+        data.toDispose = [];
+        data.icon = $('.icon');
+        data.checkbox = createCheckbox(data.toDispose);
+        data.toDispose.push(dom.addStandardDisposableListener(data.checkbox, 'change', (e) => {
+            this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
+        }));
+        dom.append(data.breakpoint, data.icon);
+        dom.append(data.breakpoint, data.checkbox);
+        data.name = dom.append(data.breakpoint, $('span.name'));
+        data.accessType = dom.append(data.breakpoint, $('span.access-type'));
+        return data;
+    }
+    renderElement(dataBreakpoint, _index, data) {
+        data.context = dataBreakpoint;
+        data.name.textContent = dataBreakpoint.description;
+        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), dataBreakpoint, this.labelService);
+        data.icon.className = ThemeIcon.asClassName(icon);
+        data.icon.title = message ? message : '';
+        data.checkbox.checked = dataBreakpoint.enabled;
+        data.breakpoint.title = message ? message : '';
+        const session = this.debugService.getViewModel().focusedSession;
+        data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsDataBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
+        if (session && !session.capabilities.supportsDataBreakpoints) {
+            data.breakpoint.title = ( localize(
+                'dataBreakpointsNotSupported',
+                "Data breakpoints are not supported by this debug type"
+            ));
+        }
+        if (dataBreakpoint.accessType) {
+            const accessType = dataBreakpoint.accessType === 'read' ? ( localize('read', "Read")) : dataBreakpoint.accessType === 'write' ? ( localize('write', "Write")) : ( localize('access', "Access"));
+            data.accessType.textContent = accessType;
+        }
+        else {
+            data.accessType.textContent = '';
+        }
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+DataBreakpointsRenderer.ID = 'databreakpoints';
+DataBreakpointsRenderer = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, ILabelService))
+], DataBreakpointsRenderer));
+let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
+    constructor(debugService, labelService) {
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    get templateId() {
+        return InstructionBreakpointsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = [];
+        data.breakpoint = dom.append(container, $('.breakpoint'));
+        data.icon = $('.icon');
+        data.checkbox = createCheckbox(data.toDispose);
+        data.toDispose.push(dom.addStandardDisposableListener(data.checkbox, 'change', (e) => {
+            this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
+        }));
+        dom.append(data.breakpoint, data.icon);
+        dom.append(data.breakpoint, data.checkbox);
+        data.name = dom.append(data.breakpoint, $('span.name'));
+        data.address = dom.append(data.breakpoint, $('span.file-path'));
+        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.toDispose.push(data.actionBar);
+        return data;
+    }
+    renderElement(breakpoint, index, data) {
+        data.context = breakpoint;
+        data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
+        data.name.textContent = breakpoint.instructionReference;
+        data.checkbox.checked = breakpoint.enabled;
+        const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService);
+        data.icon.className = ThemeIcon.asClassName(icon);
+        data.breakpoint.title = breakpoint.message || message || '';
+        const debugActive = this.debugService.state === 3  || this.debugService.state === 2 ;
+        if (debugActive && !breakpoint.verified) {
+            data.breakpoint.classList.add('disabled');
+        }
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+InstructionBreakpointsRenderer.ID = 'instructionBreakpoints';
+InstructionBreakpointsRenderer = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, ILabelService))
+], InstructionBreakpointsRenderer));
+function openBreakpointSource(breakpoint, sideBySide, preserveFocus, pinned, debugService, editorService) {
+    if (breakpoint.uri.scheme === DEBUG_SCHEME && debugService.state === 0 ) {
+        return Promise.resolve(undefined);
+    }
+    const selection = breakpoint.endLineNumber ? {
+        startLineNumber: breakpoint.lineNumber,
+        endLineNumber: breakpoint.endLineNumber,
+        startColumn: breakpoint.column || 1,
+        endColumn: breakpoint.endColumn || 1073741824
+    } : {
+        startLineNumber: breakpoint.lineNumber,
+        startColumn: breakpoint.column || 1,
+        endLineNumber: breakpoint.lineNumber,
+        endColumn: breakpoint.column || 1073741824
+    };
+    return editorService.openEditor({
+        resource: breakpoint.uri,
+        options: {
+            preserveFocus,
+            selection,
+            revealIfOpened: true,
+            selectionRevealType: 1 ,
+            pinned
+        }
+    }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+}
+function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1, labelService) {
+    const debugActive = state === 3  || state === 2 ;
+    const breakpointIcon = breakpoint$1 instanceof DataBreakpoint ? dataBreakpoint : breakpoint$1 instanceof FunctionBreakpoint ? functionBreakpoint : breakpoint$1.logMessage ? logBreakpoint : breakpoint;
+    if (!breakpoint$1.enabled || !breakpointsActivated) {
+        return {
+            icon: breakpointIcon.disabled,
+            message: breakpoint$1.logMessage ? ( localize('disabledLogpoint', "Disabled Logpoint")) : ( localize('disabledBreakpoint', "Disabled Breakpoint")),
+        };
+    }
+    const appendMessage = (text) => {
+        return ('message' in breakpoint$1 && breakpoint$1.message) ? text.concat(', ' + breakpoint$1.message) : text;
+    };
+    if (debugActive && !breakpoint$1.verified) {
+        return {
+            icon: breakpointIcon.unverified,
+            message: ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : (breakpoint$1.logMessage ? ( localize('unverifiedLogpoint', "Unverified Logpoint")) : ( localize('unverifiedBreakpoint', "Unverified Breakpoint"))),
+            showAdapterUnverifiedMessage: true
+        };
+    }
+    if (breakpoint$1 instanceof DataBreakpoint) {
+        if (!breakpoint$1.supported) {
+            return {
+                icon: breakpointIcon.unverified,
+                message: ( localize(
+                    'dataBreakpointUnsupported',
+                    "Data breakpoints not supported by this debug type"
+                )),
+            };
+        }
+        return {
+            icon: breakpointIcon.regular,
+            message: breakpoint$1.message || ( localize('dataBreakpoint', "Data Breakpoint"))
+        };
+    }
+    if (breakpoint$1 instanceof FunctionBreakpoint) {
+        if (!breakpoint$1.supported) {
+            return {
+                icon: breakpointIcon.unverified,
+                message: ( localize(
+                    'functionBreakpointUnsupported',
+                    "Function breakpoints not supported by this debug type"
+                )),
+            };
+        }
+        const messages = [];
+        messages.push(breakpoint$1.message || ( localize('functionBreakpoint', "Function Breakpoint")));
+        if (breakpoint$1.condition) {
+            messages.push(( localize('expression', "Expression condition: {0}", breakpoint$1.condition)));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localize('hitCount', "Hit Count: {0}", breakpoint$1.hitCondition)));
+        }
+        return {
+            icon: breakpointIcon.regular,
+            message: appendMessage(messages.join('\n'))
+        };
+    }
+    if (breakpoint$1 instanceof InstructionBreakpoint) {
+        if (!breakpoint$1.supported) {
+            return {
+                icon: breakpointIcon.unverified,
+                message: ( localize(
+                    'instructionBreakpointUnsupported',
+                    "Instruction breakpoints not supported by this debug type"
+                )),
+            };
+        }
+        const messages = [];
+        if (breakpoint$1.message) {
+            messages.push(breakpoint$1.message);
+        }
+        else if (breakpoint$1.instructionReference) {
+            messages.push(( localize(
+                'instructionBreakpointAtAddress',
+                "Instruction breakpoint at address {0}",
+                breakpoint$1.instructionReference
+            )));
+        }
+        else {
+            messages.push(( localize('instructionBreakpoint', "Instruction breakpoint")));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localize('hitCount', "Hit Count: {0}", breakpoint$1.hitCondition)));
+        }
+        return {
+            icon: breakpointIcon.regular,
+            message: appendMessage(messages.join('\n'))
+        };
+    }
+    if (breakpoint$1.logMessage || breakpoint$1.condition || breakpoint$1.hitCondition) {
+        const messages = [];
+        if (!breakpoint$1.supported) {
+            return {
+                icon: debugBreakpointUnsupported,
+                message: ( localize(
+                    'breakpointUnsupported',
+                    "Breakpoints of this type are not supported by the debugger"
+                )),
+            };
+        }
+        if (breakpoint$1.logMessage) {
+            messages.push(( localize('logMessage', "Log Message: {0}", breakpoint$1.logMessage)));
+        }
+        if (breakpoint$1.condition) {
+            messages.push(( localize('expression', "Expression condition: {0}", breakpoint$1.condition)));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localize('hitCount', "Hit Count: {0}", breakpoint$1.hitCondition)));
+        }
+        return {
+            icon: breakpoint$1.logMessage ? logBreakpoint.regular : conditionalBreakpoint.regular,
+            message: appendMessage(messages.join('\n'))
+        };
+    }
+    const message = ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : breakpoint$1 instanceof Breakpoint && labelService ? labelService.getUriLabel(breakpoint$1.uri) : ( localize('breakpoint', "Breakpoint"));
+    return {
+        icon: breakpointIcon.regular,
+        message
+    };
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.addFunctionBreakpointAction',
+            title: {
+                value: ( localize('addFunctionBreakpoint', "Add Function Breakpoint")),
+                original: 'Add Function Breakpoint',
+                mnemonicTitle: ( localize(
+                    { key: 'miFunctionBreakpoint', comment: ['&& denotes a mnemonic'] },
+                    "&&Function Breakpoint..."
+                ))
+            },
+            f1: true,
+            icon: watchExpressionsAddFuncBreakpoint,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 10,
+                    when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                }, {
+                    id: MenuId.MenubarNewBreakpointMenu,
+                    group: '1_breakpoints',
+                    order: 3,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE
+                }]
+        });
+    }
+    run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        debugService.addFunctionBreakpoint();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.toggleBreakpointsActivatedAction',
+            title: { value: ( localize('activateBreakpoints', "Toggle Activate Breakpoints")), original: 'Toggle Activate Breakpoints' },
+            f1: true,
+            icon: breakpointsActivate,
+            menu: {
+                id: MenuId.ViewTitle,
+                group: 'navigation',
+                order: 20,
+                when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+            }
+        });
+    }
+    run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        debugService.setBreakpointsActivated(!debugService.getModel().areBreakpointsActivated());
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.removeBreakpoint',
+            title: ( localize('removeBreakpoint', "Remove Breakpoint")),
+            icon: Codicon.removeClose,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: '3_modification',
+                    order: 10,
+                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                }, {
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'inline',
+                    order: 20,
+                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                }]
+        });
+    }
+    async run(accessor, breakpoint) {
+        const debugService = accessor.get(IDebugService);
+        if (breakpoint instanceof Breakpoint) {
+            await debugService.removeBreakpoints(breakpoint.getId());
+        }
+        else if (breakpoint instanceof FunctionBreakpoint) {
+            await debugService.removeFunctionBreakpoints(breakpoint.getId());
+        }
+        else if (breakpoint instanceof DataBreakpoint) {
+            await debugService.removeDataBreakpoints(breakpoint.getId());
+        }
+        else if (breakpoint instanceof InstructionBreakpoint) {
+            await debugService.removeInstructionBreakpoints(breakpoint.instructionReference);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.removeAllBreakpoints',
+            title: {
+                original: 'Remove All Breakpoints',
+                value: ( localize('removeAllBreakpoints', "Remove All Breakpoints")),
+                mnemonicTitle: ( localize(
+                    { key: 'miRemoveAllBreakpoints', comment: ['&& denotes a mnemonic'] },
+                    "Remove &&All Breakpoints"
+                ))
+            },
+            f1: true,
+            icon: breakpointsRemoveAll,
+            menu: [{
+                    id: MenuId.ViewTitle,
+                    group: 'navigation',
+                    order: 30,
+                    when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                }, {
+                    id: MenuId.DebugBreakpointsContext,
+                    group: '3_modification',
+                    order: 20,
+                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                }, {
+                    id: MenuId.MenubarDebugMenu,
+                    group: '5_breakpoints',
+                    order: 3,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE
+                }]
+        });
+    }
+    run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        debugService.removeBreakpoints();
+        debugService.removeFunctionBreakpoints();
+        debugService.removeDataBreakpoints();
+        debugService.removeInstructionBreakpoints();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.enableAllBreakpoints',
+            title: {
+                original: 'Enable All Breakpoints',
+                value: ( localize('enableAllBreakpoints', "Enable All Breakpoints")),
+                mnemonicTitle: ( localize(
+                    { key: 'miEnableAllBreakpoints', comment: ['&& denotes a mnemonic'] },
+                    "&&Enable All Breakpoints"
+                )),
+            },
+            f1: true,
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'z_commands',
+                    order: 10,
+                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                }, {
+                    id: MenuId.MenubarDebugMenu,
+                    group: '5_breakpoints',
+                    order: 1,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE
+                }]
+        });
+    }
+    async run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        await debugService.enableOrDisableBreakpoints(true);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.disableAllBreakpoints',
+            title: {
+                original: 'Disable All Breakpoints',
+                value: ( localize('disableAllBreakpoints', "Disable All Breakpoints")),
+                mnemonicTitle: ( localize(
+                    { key: 'miDisableAllBreakpoints', comment: ['&& denotes a mnemonic'] },
+                    "Disable A&&ll Breakpoints"
+                ))
+            },
+            f1: true,
+            precondition: CONTEXT_DEBUGGERS_AVAILABLE,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'z_commands',
+                    order: 20,
+                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                }, {
+                    id: MenuId.MenubarDebugMenu,
+                    group: '5_breakpoints',
+                    order: 2,
+                    when: CONTEXT_DEBUGGERS_AVAILABLE
+                }]
+        });
+    }
+    async run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        await debugService.enableOrDisableBreakpoints(false);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.reapplyBreakpointsAction',
+            title: { value: ( localize('reapplyAllBreakpoints', "Reapply All Breakpoints")), original: 'Reapply All Breakpoints' },
+            f1: true,
+            precondition: CONTEXT_IN_DEBUG_MODE,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'z_commands',
+                    order: 30,
+                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                }]
+        });
+    }
+    async run(accessor) {
+        const debugService = accessor.get(IDebugService);
+        await debugService.setBreakpointsActivated(true);
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'debug.editBreakpoint',
+            viewId: BREAKPOINTS_VIEW_ID,
+            title: ( localize('editCondition', "Edit Condition...")),
+            icon: Codicon.edit,
+            precondition: CONTEXT_BREAKPOINT_SUPPORTS_CONDITION,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'navigation',
+                    order: 10
+                }, {
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'inline',
+                    order: 10
+                }]
+        });
+    }
+    async runInView(accessor, view, breakpoint) {
+        const debugService = accessor.get(IDebugService);
+        const editorService = accessor.get(IEditorService);
+        if (breakpoint instanceof Breakpoint) {
+            const editor = await openBreakpointSource(breakpoint, false, false, true, debugService, editorService);
+            if (editor) {
+                const codeEditor = editor.getControl();
+                if (isCodeEditor(codeEditor)) {
+                    codeEditor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(breakpoint.lineNumber, breakpoint.column);
+                }
+            }
+        }
+        else if (breakpoint instanceof FunctionBreakpoint) {
+            const contextMenuService = accessor.get(IContextMenuService);
+            const actions = [( new Action('breakpoint.editCondition', ( localize('editCondition', "Edit Condition...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'condition' }))),
+                ( new Action('breakpoint.editCondition', ( localize('editHitCount', "Edit Hit Count...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'hitCount' })))];
+            const domNode = breakpointIdToActionBarDomeNode.get(breakpoint.getId());
+            if (domNode) {
+                contextMenuService.showContextMenu({
+                    getActions: () => actions,
+                    getAnchor: () => domNode,
+                    onHide: () => dispose(actions)
+                });
+            }
+        }
+        else {
+            view.renderInputBox({ breakpoint, type: 'condition' });
+        }
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'debug.editFunctionBreakpoint',
+            viewId: BREAKPOINTS_VIEW_ID,
+            title: ( localize('editBreakpoint', "Edit Function Breakpoint...")),
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: '1_breakpoints',
+                    order: 10,
+                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint'))
+                }]
+        });
+    }
+    runInView(_accessor, view, breakpoint) {
+        view.renderInputBox({ breakpoint, type: 'name' });
+    }
+});
+registerAction2(class extends ViewAction {
+    constructor() {
+        super({
+            id: 'debug.editFunctionBreakpointHitCount',
+            viewId: BREAKPOINTS_VIEW_ID,
+            title: ( localize('editHitCount', "Edit Hit Count...")),
+            precondition: CONTEXT_BREAKPOINT_SUPPORTS_CONDITION,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'navigation',
+                    order: 20,
+                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint'))
+                }]
+        });
+    }
+    runInView(_accessor, view, breakpoint) {
+        view.renderInputBox({ breakpoint, type: 'hitCount' });
+    }
+});
+export { getBreakpointMessageAndIcon, openBreakpointSource };