@codingame/monaco-vscode-api 1.85.0 → 1.85.2

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

@@ -0,0 +1,1591 @@
+import { __decorate, __param } from '../../../../../../../external/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 { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.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 { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { createAndFillInActionBarActions, createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
+import { registerAction2, Action2, MenuId, IMenuService } 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 { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { WorkbenchList } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ViewAction, ViewPane } from '../../../browser/parts/views/viewPane.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { debugBreakpointUnsupported, logBreakpoint, conditionalBreakpoint, watchExpressionsAddFuncBreakpoint, breakpointsActivate, breakpointsRemoveAll, 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, CONTEXT_BREAKPOINT_INPUT_FOCUSED, CONTEXT_BREAKPOINTS_FOCUSED, DEBUG_SCHEME, DebuggerString } from '../common/debug.js';
+import { DataBreakpoint, FunctionBreakpoint, InstructionBreakpoint, Breakpoint, ExceptionBreakpoint } from '../common/debugModel.js';
+import { DisassemblyViewInput } from '../common/disassemblyViewInput.js';
+import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IHoverService } from '../../../services/hover/browser/hover.js';
+var BreakpointsRenderer_1, FunctionBreakpointsRenderer_1, DataBreakpointsRenderer_1, InstructionBreakpointsRenderer_1;
+const $ = dom.$;
+function createCheckbox(disposables) {
+    const checkbox = $('input');
+    checkbox.type = 'checkbox';
+    checkbox.tabIndex = -1;
+    disposables.push(Gesture.ignoreTarget(checkbox));
+    return checkbox;
+}
+const MAX_VISIBLE_BREAKPOINTS = 9;
+function getExpandedBodySize(model, sessionId, countLimit) {
+    const length = model.getBreakpoints().length + model.getExceptionBreakpointsForSession(sessionId).length + model.getFunctionBreakpoints().length + model.getDataBreakpoints().length + model.getInstructionBreakpoints().length;
+    return Math.min(countLimit, length) * 22;
+}
+let BreakpointsView = class BreakpointsView extends ViewPane {
+    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, themeService, editorService, contextViewService, configurationService, viewDescriptorService, contextKeyService, openerService, telemetryService, labelService, menuService, hoverService, languageService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.debugService = debugService;
+        this.editorService = editorService;
+        this.contextViewService = contextViewService;
+        this.labelService = labelService;
+        this.hoverService = hoverService;
+        this.languageService = languageService;
+        this.needsRefresh = false;
+        this.needsStateChange = false;
+        this.ignoreLayout = false;
+        this.autoFocusedIndex = -1;
+        this.menu = menuService.createMenu(MenuId.DebugBreakpointsContext, contextKeyService);
+        this._register(this.menu);
+        this.breakpointItemType = CONTEXT_BREAKPOINT_ITEM_TYPE.bindTo(contextKeyService);
+        this.breakpointSupportsCondition = CONTEXT_BREAKPOINT_SUPPORTS_CONDITION.bindTo(contextKeyService);
+        this.breakpointInputFocused = CONTEXT_BREAKPOINT_INPUT_FOCUSED.bindTo(contextKeyService);
+        this._register(this.debugService.getModel().onDidChangeBreakpoints(() => this.onBreakpointsChange()));
+        this._register(this.debugService.getViewModel().onDidFocusSession(() => this.onBreakpointsChange()));
+        this._register(this.debugService.onDidChangeState(() => this.onStateChange()));
+        this.hintDelayer = this._register(( new RunOnceScheduler(() => this.updateBreakpointsHint(true), 4000)));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.element.classList.add('debug-pane');
+        container.classList.add('debug-breakpoints');
+        const delegate = ( new BreakpointsDelegate(this));
+        this.list = this.instantiationService.createInstance(WorkbenchList, 'Breakpoints', container, delegate, [
+            this.instantiationService.createInstance(BreakpointsRenderer, this.menu, this.breakpointSupportsCondition, this.breakpointItemType),
+            ( new ExceptionBreakpointsRenderer(
+                this.menu,
+                this.breakpointSupportsCondition,
+                this.breakpointItemType,
+                this.debugService
+            )),
+            ( new ExceptionBreakpointInputRenderer(this, this.debugService, this.contextViewService)),
+            this.instantiationService.createInstance(FunctionBreakpointsRenderer, this.menu, this.breakpointSupportsCondition, this.breakpointItemType),
+            ( new FunctionBreakpointInputRenderer(this, this.debugService, this.contextViewService, this.labelService)),
+            this.instantiationService.createInstance(DataBreakpointsRenderer, this.menu, this.breakpointSupportsCondition, this.breakpointItemType),
+            ( new DataBreakpointInputRenderer(this, this.debugService, this.contextViewService, this.labelService)),
+            this.instantiationService.createInstance(InstructionBreakpointsRenderer),
+        ], {
+            identityProvider: { getId: (element) => element.getId() },
+            multipleSelectionSupport: false,
+            keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e },
+            accessibilityProvider: ( new BreakpointsAccessibilityProvider(this.debugService, this.labelService)),
+            overrideStyles: {
+                listBackground: this.getBackgroundColor()
+            }
+        });
+        CONTEXT_BREAKPOINTS_FOCUSED.bindTo(this.list.contextKeyService);
+        this._register(this.list.onContextMenu(this.onListContextMenu, this));
+        this.list.onMouseMiddleClick(async ({ element }) => {
+            if (element instanceof Breakpoint) {
+                await this.debugService.removeBreakpoints(element.getId());
+            }
+            else if (element instanceof FunctionBreakpoint) {
+                await this.debugService.removeFunctionBreakpoints(element.getId());
+            }
+            else if (element instanceof DataBreakpoint) {
+                await this.debugService.removeDataBreakpoints(element.getId());
+            }
+            else if (element instanceof InstructionBreakpoint) {
+                await this.debugService.removeInstructionBreakpoints(element.instructionReference, element.offset);
+            }
+        });
+        this._register(this.list.onDidOpen(async (e) => {
+            if (!e.element) {
+                return;
+            }
+            if (dom.isMouseEvent(e.browserEvent) && e.browserEvent.button === 1) {
+                return;
+            }
+            if (e.element instanceof Breakpoint) {
+                openBreakpointSource(e.element, e.sideBySide, e.editorOptions.preserveFocus || false, e.editorOptions.pinned || !e.editorOptions.preserveFocus, this.debugService, this.editorService);
+            }
+            if (e.element instanceof InstructionBreakpoint) {
+                const disassemblyView = await this.editorService.openEditor(DisassemblyViewInput.instance);
+                disassemblyView.goToInstructionAndOffset(e.element.instructionReference, e.element.offset, dom.isMouseEvent(e.browserEvent) && e.browserEvent.detail === 2);
+            }
+            if (dom.isMouseEvent(e.browserEvent) && e.browserEvent.detail === 2 && e.element instanceof FunctionBreakpoint && e.element !== this.inputBoxData?.breakpoint) {
+                this.renderInputBox({ breakpoint: e.element, type: 'name' });
+            }
+        }));
+        this.list.splice(0, this.list.length, this.elements);
+        this._register(this.onDidChangeBodyVisibility(visible => {
+            if (visible) {
+                if (this.needsRefresh) {
+                    this.onBreakpointsChange();
+                }
+                if (this.needsStateChange) {
+                    this.onStateChange();
+                }
+            }
+        }));
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        this._register(containerModel.onDidChangeAllViewDescriptors(() => {
+            this.updateSize();
+        }));
+    }
+    renderHeaderTitle(container, title) {
+        super.renderHeaderTitle(container, title);
+        const iconLabelContainer = dom.append(container, $('span.breakpoint-warning'));
+        this.hintContainer = this._register(( new IconLabel(iconLabelContainer, {
+            supportIcons: true, hoverDelegate: {
+                showHover: (options, focus) => this.hoverService.showHover({ content: options.content, target: this.hintContainer.element }, focus),
+                delay: this.configurationService.getValue('workbench.hover.delay')
+            }
+        })));
+        dom.hide(this.hintContainer.element);
+    }
+    focus() {
+        super.focus();
+        this.list?.domFocus();
+    }
+    renderInputBox(data) {
+        this._inputBoxData = data;
+        this.onBreakpointsChange();
+        this._inputBoxData = undefined;
+    }
+    get inputBoxData() {
+        return this._inputBoxData;
+    }
+    layoutBody(height, width) {
+        if (this.ignoreLayout) {
+            return;
+        }
+        super.layoutBody(height, width);
+        this.list?.layout(height, width);
+        try {
+            this.ignoreLayout = true;
+            this.updateSize();
+        }
+        finally {
+            this.ignoreLayout = false;
+        }
+    }
+    onListContextMenu(e) {
+        const element = e.element;
+        const type = element instanceof Breakpoint ? 'breakpoint' : element instanceof ExceptionBreakpoint ? 'exceptionBreakpoint' :
+            element instanceof FunctionBreakpoint ? 'functionBreakpoint' : element instanceof DataBreakpoint ? 'dataBreakpoint' :
+                element instanceof InstructionBreakpoint ? 'instructionBreakpoint' : undefined;
+        this.breakpointItemType.set(type);
+        const session = this.debugService.getViewModel().focusedSession;
+        const conditionSupported = element instanceof ExceptionBreakpoint ? element.supportsCondition : (!session || !!session.capabilities.supportsConditionalBreakpoints);
+        this.breakpointSupportsCondition.set(conditionSupported);
+        const secondary = [];
+        createAndFillInContextMenuActions(this.menu, { arg: e.element, shouldForwardArgs: false }, { primary: [], secondary }, 'inline');
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => secondary,
+            getActionsContext: () => element
+        });
+    }
+    updateSize() {
+        const containerModel = this.viewDescriptorService.getViewContainerModel(this.viewDescriptorService.getViewContainerByViewId(this.id));
+        const sessionId = this.debugService.getViewModel().focusedSession?.getId();
+        this.minimumBodySize = this.orientation === 0  ? getExpandedBodySize(this.debugService.getModel(), sessionId, MAX_VISIBLE_BREAKPOINTS) : 170;
+        this.maximumBodySize = this.orientation === 0  && containerModel.visibleViewDescriptors.length > 1 ? getExpandedBodySize(this.debugService.getModel(), sessionId, Number.POSITIVE_INFINITY) : Number.POSITIVE_INFINITY;
+    }
+    updateBreakpointsHint(delayed = false) {
+        if (!this.hintContainer) {
+            return;
+        }
+        const currentType = this.debugService.getViewModel().focusedSession?.configuration.type;
+        const dbg = currentType ? this.debugService.getAdapterManager().getDebugger(currentType) : undefined;
+        const message = dbg?.strings?.[DebuggerString.UnverifiedBreakpoints];
+        const debuggerHasUnverifiedBps = message && this.debugService.getModel().getBreakpoints().filter(bp => {
+            if (bp.verified || !bp.enabled) {
+                return false;
+            }
+            const langId = this.languageService.guessLanguageIdByFilepathOrFirstLine(bp.uri);
+            return langId && dbg.interestedInLanguage(langId);
+        });
+        if (message && debuggerHasUnverifiedBps?.length && this.debugService.getModel().areBreakpointsActivated()) {
+            if (delayed) {
+                const mdown = ( new MarkdownString(undefined, { isTrusted: true })).appendMarkdown(message);
+                this.hintContainer.setLabel('$(warning)', undefined, { title: { markdown: mdown, markdownNotSupportedFallback: message } });
+                dom.show(this.hintContainer.element);
+            }
+            else {
+                this.hintDelayer.schedule();
+            }
+        }
+        else {
+            dom.hide(this.hintContainer.element);
+        }
+    }
+    onBreakpointsChange() {
+        if (this.isBodyVisible()) {
+            this.updateSize();
+            if (this.list) {
+                const lastFocusIndex = this.list.getFocus()[0];
+                const needsRefocus = lastFocusIndex && !this.elements.includes(this.list.element(lastFocusIndex));
+                this.list.splice(0, this.list.length, this.elements);
+                this.needsRefresh = false;
+                if (needsRefocus) {
+                    this.list.focusNth(Math.min(lastFocusIndex, this.list.length - 1));
+                }
+            }
+            this.updateBreakpointsHint();
+        }
+        else {
+            this.needsRefresh = true;
+        }
+    }
+    onStateChange() {
+        if (this.isBodyVisible()) {
+            this.needsStateChange = false;
+            const thread = this.debugService.getViewModel().focusedThread;
+            let found = false;
+            if (thread && thread.stoppedDetails && thread.stoppedDetails.hitBreakpointIds && thread.stoppedDetails.hitBreakpointIds.length > 0) {
+                const hitBreakpointIds = thread.stoppedDetails.hitBreakpointIds;
+                const elements = this.elements;
+                const index = elements.findIndex(e => {
+                    const id = e.getIdFromAdapter(thread.session.getId());
+                    return typeof id === 'number' && hitBreakpointIds.indexOf(id) !== -1;
+                });
+                if (index >= 0) {
+                    this.list.setFocus([index]);
+                    this.list.setSelection([index]);
+                    found = true;
+                    this.autoFocusedIndex = index;
+                }
+            }
+            if (!found) {
+                const focus = this.list.getFocus();
+                const selection = this.list.getSelection();
+                if (this.autoFocusedIndex >= 0 && equals(focus, selection) && focus.indexOf(this.autoFocusedIndex) >= 0) {
+                    this.list.setFocus([]);
+                    this.list.setSelection([]);
+                }
+                this.autoFocusedIndex = -1;
+            }
+            this.updateBreakpointsHint();
+        }
+        else {
+            this.needsStateChange = true;
+        }
+    }
+    get elements() {
+        const model = this.debugService.getModel();
+        const sessionId = this.debugService.getViewModel().focusedSession?.getId();
+        const elements = model.getExceptionBreakpointsForSession(sessionId).concat(model.getFunctionBreakpoints()).concat(model.getDataBreakpoints()).concat(model.getBreakpoints()).concat(model.getInstructionBreakpoints());
+        return elements;
+    }
+};
+BreakpointsView = ( __decorate([
+    ( __param(1, IContextMenuService)),
+    ( __param(2, IDebugService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IContextViewService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IContextKeyService)),
+    ( __param(11, IOpenerService)),
+    ( __param(12, ITelemetryService)),
+    ( __param(13, ILabelService)),
+    ( __param(14, IMenuService)),
+    ( __param(15, IHoverService)),
+    ( __param(16, ILanguageService))
+], BreakpointsView));
+class BreakpointsDelegate {
+    constructor(view) {
+        this.view = view;
+    }
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        if (element instanceof Breakpoint) {
+            return BreakpointsRenderer.ID;
+        }
+        if (element instanceof FunctionBreakpoint) {
+            const inputBoxBreakpoint = this.view.inputBoxData?.breakpoint;
+            if (!element.name || (inputBoxBreakpoint && inputBoxBreakpoint.getId() === element.getId())) {
+                return FunctionBreakpointInputRenderer.ID;
+            }
+            return FunctionBreakpointsRenderer.ID;
+        }
+        if (element instanceof ExceptionBreakpoint) {
+            const inputBoxBreakpoint = this.view.inputBoxData?.breakpoint;
+            if (inputBoxBreakpoint && inputBoxBreakpoint.getId() === element.getId()) {
+                return ExceptionBreakpointInputRenderer.ID;
+            }
+            return ExceptionBreakpointsRenderer.ID;
+        }
+        if (element instanceof DataBreakpoint) {
+            const inputBoxBreakpoint = this.view.inputBoxData?.breakpoint;
+            if (inputBoxBreakpoint && inputBoxBreakpoint.getId() === element.getId()) {
+                return DataBreakpointInputRenderer.ID;
+            }
+            return DataBreakpointsRenderer.ID;
+        }
+        if (element instanceof InstructionBreakpoint) {
+            return InstructionBreakpointsRenderer.ID;
+        }
+        return '';
+    }
+}
+const breakpointIdToActionBarDomeNode = ( new Map());
+let BreakpointsRenderer = class BreakpointsRenderer {
+    static { BreakpointsRenderer_1 = this; }
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'breakpoints'; }
+    get templateId() {
+        return BreakpointsRenderer_1.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 = BreakpointsRenderer_1 = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, ILabelService))
+], BreakpointsRenderer));
+class ExceptionBreakpointsRenderer {
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+    }
+    static { this.ID = 'exceptionbreakpoints'; }
+    get templateId() {
+        return ExceptionBreakpointsRenderer.ID;
+    }
+    renderTemplate(container) {
+        const data = Object.create(null);
+        data.toDispose = [];
+        data.breakpoint = dom.append(container, $('.breakpoint'));
+        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.checkbox);
+        data.name = dom.append(data.breakpoint, $('span.name'));
+        data.condition = dom.append(data.breakpoint, $('span.condition'));
+        data.breakpoint.classList.add('exception');
+        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.toDispose.push(data.actionBar);
+        return data;
+    }
+    renderElement(exceptionBreakpoint, index, data) {
+        data.context = exceptionBreakpoint;
+        data.name.textContent = exceptionBreakpoint.label || `${exceptionBreakpoint.filter} exceptions`;
+        data.breakpoint.title = exceptionBreakpoint.verified ? (exceptionBreakpoint.description || data.name.textContent) : exceptionBreakpoint.message || ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'unverifiedExceptionBreakpoint',
+            "Unverified Exception Breakpoint"
+        ));
+        data.breakpoint.classList.toggle('disabled', !exceptionBreakpoint.verified);
+        data.checkbox.checked = exceptionBreakpoint.enabled;
+        data.condition.textContent = exceptionBreakpoint.condition || '';
+        data.condition.title = ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'expressionCondition',
+            "Expression condition: {0}",
+            exceptionBreakpoint.condition
+        ));
+        const primary = [];
+        this.breakpointSupportsCondition.set(exceptionBreakpoint.supportsCondition);
+        this.breakpointItemType.set('exceptionBreakpoint');
+        createAndFillInActionBarActions(this.menu, { arg: exceptionBreakpoint, shouldForwardArgs: true }, { primary, secondary: [] }, 'inline');
+        data.actionBar.clear();
+        data.actionBar.push(primary, { icon: true, label: false });
+        breakpointIdToActionBarDomeNode.set(exceptionBreakpoint.getId(), data.actionBar.domNode);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+}
+let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
+    static { FunctionBreakpointsRenderer_1 = this; }
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'functionbreakpoints'; }
+    get templateId() {
+        return FunctionBreakpointsRenderer_1.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 = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'expressionAndHitCount',
+                "Condition: {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 = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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 = FunctionBreakpointsRenderer_1 = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, ILabelService))
+], FunctionBreakpointsRenderer));
+let DataBreakpointsRenderer = class DataBreakpointsRenderer {
+    static { DataBreakpointsRenderer_1 = this; }
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+        this.menu = menu;
+        this.breakpointSupportsCondition = breakpointSupportsCondition;
+        this.breakpointItemType = breakpointItemType;
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'databreakpoints'; }
+    get templateId() {
+        return DataBreakpointsRenderer_1.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'));
+        data.condition = dom.append(data.breakpoint, $('span.condition'));
+        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.toDispose.push(data.actionBar);
+        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 = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakpointsNotSupported',
+                "Data breakpoints are not supported by this debug type"
+            ));
+        }
+        if (dataBreakpoint.accessType) {
+            const accessType = dataBreakpoint.accessType === 'read' ? ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'read', "Read")) : dataBreakpoint.accessType === 'write' ? ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'write', "Write")) : ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'access', "Access"));
+            data.accessType.textContent = accessType;
+        }
+        else {
+            data.accessType.textContent = '';
+        }
+        if (dataBreakpoint.condition && dataBreakpoint.hitCondition) {
+            data.condition.textContent = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'expressionAndHitCount',
+                "Condition: {0} | Hit Count: {1}",
+                dataBreakpoint.condition,
+                dataBreakpoint.hitCondition
+            ));
+        }
+        else {
+            data.condition.textContent = dataBreakpoint.condition || dataBreakpoint.hitCondition || '';
+        }
+        const primary = [];
+        this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
+        this.breakpointItemType.set('dataBreakpoint');
+        createAndFillInActionBarActions(this.menu, { arg: dataBreakpoint, shouldForwardArgs: true }, { primary, secondary: [] }, 'inline');
+        data.actionBar.clear();
+        data.actionBar.push(primary, { icon: true, label: false });
+        breakpointIdToActionBarDomeNode.set(dataBreakpoint.getId(), data.actionBar.domNode);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+};
+DataBreakpointsRenderer = DataBreakpointsRenderer_1 = ( __decorate([
+    ( __param(3, IDebugService)),
+    ( __param(4, ILabelService))
+], DataBreakpointsRenderer));
+let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
+    static { InstructionBreakpointsRenderer_1 = this; }
+    constructor(debugService, labelService) {
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'instructionBreakpoints'; }
+    get templateId() {
+        return InstructionBreakpointsRenderer_1.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 = '0x' + ( breakpoint.address.toString(16));
+        data.name.title = `Decimal address: breakpoint.address.toString()`;
+        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 = InstructionBreakpointsRenderer_1 = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, ILabelService))
+], InstructionBreakpointsRenderer));
+class FunctionBreakpointInputRenderer {
+    constructor(view, debugService, contextViewService, labelService) {
+        this.view = view;
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'functionbreakpointinput'; }
+    get templateId() {
+        return FunctionBreakpointInputRenderer.ID;
+    }
+    renderTemplate(container) {
+        const template = Object.create(null);
+        const toDispose = [];
+        const breakpoint = dom.append(container, $('.breakpoint'));
+        template.icon = $('.icon');
+        template.checkbox = createCheckbox(toDispose);
+        dom.append(breakpoint, template.icon);
+        dom.append(breakpoint, template.checkbox);
+        this.view.breakpointInputFocused.set(true);
+        const inputBoxContainer = dom.append(breakpoint, $('.inputBoxContainer'));
+        const inputBox = ( new InputBox(
+            inputBoxContainer,
+            this.contextViewService,
+            { inputBoxStyles: defaultInputBoxStyles }
+        ));
+        const wrapUp = (success) => {
+            template.updating = true;
+            try {
+                this.view.breakpointInputFocused.set(false);
+                const id = template.breakpoint.getId();
+                if (success) {
+                    if (template.type === 'name') {
+                        this.debugService.updateFunctionBreakpoint(id, { name: inputBox.value });
+                    }
+                    if (template.type === 'condition') {
+                        this.debugService.updateFunctionBreakpoint(id, { condition: inputBox.value });
+                    }
+                    if (template.type === 'hitCount') {
+                        this.debugService.updateFunctionBreakpoint(id, { hitCondition: inputBox.value });
+                    }
+                }
+                else {
+                    if (template.type === 'name' && !template.breakpoint.name) {
+                        this.debugService.removeFunctionBreakpoints(id);
+                    }
+                    else {
+                        this.view.renderInputBox(undefined);
+                    }
+                }
+            }
+            finally {
+                template.updating = false;
+            }
+        };
+        toDispose.push(dom.addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+            const isEscape = e.equals(9 );
+            const isEnter = e.equals(3 );
+            if (isEscape || isEnter) {
+                e.preventDefault();
+                e.stopPropagation();
+                wrapUp(isEnter);
+            }
+        }));
+        toDispose.push(dom.addDisposableListener(inputBox.inputElement, 'blur', () => {
+            if (!template.updating) {
+                wrapUp(!!inputBox.value);
+            }
+        }));
+        template.inputBox = inputBox;
+        template.toDispose = toDispose;
+        return template;
+    }
+    renderElement(functionBreakpoint, _index, data) {
+        data.breakpoint = functionBreakpoint;
+        data.type = this.view.inputBoxData?.type || '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.checkbox.disabled = true;
+        data.inputBox.value = functionBreakpoint.name || '';
+        let placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'functionBreakpointPlaceholder',
+            "Function to break on"
+        ));
+        let ariaLabel = ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'functionBreakPointInputAriaLabel',
+            "Type function breakpoint."
+        ));
+        if (data.type === 'condition') {
+            data.inputBox.value = functionBreakpoint.condition || '';
+            placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'functionBreakpointExpressionPlaceholder',
+                "Break when expression evaluates to true"
+            ));
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'functionBreakPointExpresionAriaLabel',
+                "Type expression. Function breakpoint will break when expression evaluates to true"
+            ));
+        }
+        else if (data.type === 'hitCount') {
+            data.inputBox.value = functionBreakpoint.hitCondition || '';
+            placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'functionBreakpointHitCountPlaceholder',
+                "Break when hit count is met"
+            ));
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'functionBreakPointHitCountAriaLabel',
+                "Type hit count. Function breakpoint will break when hit count is met."
+            ));
+        }
+        data.inputBox.setAriaLabel(ariaLabel);
+        data.inputBox.setPlaceHolder(placeholder);
+        setTimeout(() => {
+            data.inputBox.focus();
+            data.inputBox.select();
+        }, 0);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+}
+class DataBreakpointInputRenderer {
+    constructor(view, debugService, contextViewService, labelService) {
+        this.view = view;
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+        this.labelService = labelService;
+    }
+    static { this.ID = 'databreakpointinput'; }
+    get templateId() {
+        return DataBreakpointInputRenderer.ID;
+    }
+    renderTemplate(container) {
+        const template = Object.create(null);
+        const toDispose = [];
+        const breakpoint = dom.append(container, $('.breakpoint'));
+        template.icon = $('.icon');
+        template.checkbox = createCheckbox(toDispose);
+        dom.append(breakpoint, template.icon);
+        dom.append(breakpoint, template.checkbox);
+        this.view.breakpointInputFocused.set(true);
+        const inputBoxContainer = dom.append(breakpoint, $('.inputBoxContainer'));
+        const inputBox = ( new InputBox(
+            inputBoxContainer,
+            this.contextViewService,
+            { inputBoxStyles: defaultInputBoxStyles }
+        ));
+        const wrapUp = (success) => {
+            template.updating = true;
+            try {
+                this.view.breakpointInputFocused.set(false);
+                const id = template.breakpoint.getId();
+                if (success) {
+                    if (template.type === 'condition') {
+                        this.debugService.updateDataBreakpoint(id, { condition: inputBox.value });
+                    }
+                    if (template.type === 'hitCount') {
+                        this.debugService.updateDataBreakpoint(id, { hitCondition: inputBox.value });
+                    }
+                }
+                else {
+                    this.view.renderInputBox(undefined);
+                }
+            }
+            finally {
+                template.updating = false;
+            }
+        };
+        toDispose.push(dom.addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+            const isEscape = e.equals(9 );
+            const isEnter = e.equals(3 );
+            if (isEscape || isEnter) {
+                e.preventDefault();
+                e.stopPropagation();
+                wrapUp(isEnter);
+            }
+        }));
+        toDispose.push(dom.addDisposableListener(inputBox.inputElement, 'blur', () => {
+            if (!template.updating) {
+                wrapUp(!!inputBox.value);
+            }
+        }));
+        template.inputBox = inputBox;
+        template.toDispose = toDispose;
+        return template;
+    }
+    renderElement(dataBreakpoint, _index, data) {
+        data.breakpoint = dataBreakpoint;
+        data.type = this.view.inputBoxData?.type || 'condition';
+        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.checkbox.disabled = true;
+        data.inputBox.value = '';
+        let placeholder = '';
+        let ariaLabel = '';
+        if (data.type === 'condition') {
+            data.inputBox.value = dataBreakpoint.condition || '';
+            placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakpointExpressionPlaceholder',
+                "Break when expression evaluates to true"
+            ));
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakPointExpresionAriaLabel',
+                "Type expression. Data breakpoint will break when expression evaluates to true"
+            ));
+        }
+        else if (data.type === 'hitCount') {
+            data.inputBox.value = dataBreakpoint.hitCondition || '';
+            placeholder = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakpointHitCountPlaceholder',
+                "Break when hit count is met"
+            ));
+            ariaLabel = ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakPointHitCountAriaLabel',
+                "Type hit count. Data breakpoint will break when hit count is met."
+            ));
+        }
+        data.inputBox.setAriaLabel(ariaLabel);
+        data.inputBox.setPlaceHolder(placeholder);
+        setTimeout(() => {
+            data.inputBox.focus();
+            data.inputBox.select();
+        }, 0);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+}
+class ExceptionBreakpointInputRenderer {
+    constructor(view, debugService, contextViewService) {
+        this.view = view;
+        this.debugService = debugService;
+        this.contextViewService = contextViewService;
+    }
+    static { this.ID = 'exceptionbreakpointinput'; }
+    get templateId() {
+        return ExceptionBreakpointInputRenderer.ID;
+    }
+    renderTemplate(container) {
+        const template = Object.create(null);
+        const toDispose = [];
+        const breakpoint = dom.append(container, $('.breakpoint'));
+        breakpoint.classList.add('exception');
+        template.checkbox = createCheckbox(toDispose);
+        dom.append(breakpoint, template.checkbox);
+        this.view.breakpointInputFocused.set(true);
+        const inputBoxContainer = dom.append(breakpoint, $('.inputBoxContainer'));
+        const inputBox = ( new InputBox(inputBoxContainer, this.contextViewService, {
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'exceptionBreakpointAriaLabel',
+                "Type exception breakpoint condition"
+            )),
+            inputBoxStyles: defaultInputBoxStyles
+        }));
+        const wrapUp = (success) => {
+            this.view.breakpointInputFocused.set(false);
+            let newCondition = template.breakpoint.condition;
+            if (success) {
+                newCondition = inputBox.value !== '' ? inputBox.value : undefined;
+            }
+            this.debugService.setExceptionBreakpointCondition(template.breakpoint, newCondition);
+        };
+        toDispose.push(dom.addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+            const isEscape = e.equals(9 );
+            const isEnter = e.equals(3 );
+            if (isEscape || isEnter) {
+                e.preventDefault();
+                e.stopPropagation();
+                wrapUp(isEnter);
+            }
+        }));
+        toDispose.push(dom.addDisposableListener(inputBox.inputElement, 'blur', () => {
+            setTimeout(() => {
+                wrapUp(true);
+            });
+        }));
+        template.inputBox = inputBox;
+        template.toDispose = toDispose;
+        return template;
+    }
+    renderElement(exceptionBreakpoint, _index, data) {
+        const placeHolder = exceptionBreakpoint.conditionDescription || ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'exceptionBreakpointPlaceholder',
+            "Break when expression evaluates to true"
+        ));
+        data.inputBox.setPlaceHolder(placeHolder);
+        data.breakpoint = exceptionBreakpoint;
+        data.checkbox.checked = exceptionBreakpoint.enabled;
+        data.checkbox.disabled = true;
+        data.inputBox.value = exceptionBreakpoint.condition || '';
+        setTimeout(() => {
+            data.inputBox.focus();
+            data.inputBox.select();
+        }, 0);
+    }
+    disposeTemplate(templateData) {
+        dispose(templateData.toDispose);
+    }
+}
+class BreakpointsAccessibilityProvider {
+    constructor(debugService, labelService) {
+        this.debugService = debugService;
+        this.labelService = labelService;
+    }
+    getWidgetAriaLabel() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'breakpoints',
+            "Breakpoints"
+        ));
+    }
+    getRole() {
+        return 'checkbox';
+    }
+    isChecked(breakpoint) {
+        return breakpoint.enabled;
+    }
+    getAriaLabel(element) {
+        if (element instanceof ExceptionBreakpoint) {
+            return ( element.toString());
+        }
+        const { message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), element, this.labelService);
+        const toString = ( element.toString());
+        return message ? `${toString}, ${message}` : toString;
+    }
+}
+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 ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'disabledLogpoint',
+                "Disabled Logpoint"
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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 ? ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'unverifiedLogpoint',
+                "Unverified Logpoint"
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'unverifiedBreakpoint',
+                "Unverified Breakpoint"
+            ))),
+            showAdapterUnverifiedMessage: true
+        };
+    }
+    if (breakpoint$1 instanceof DataBreakpoint) {
+        if (!breakpoint$1.supported) {
+            return {
+                icon: breakpointIcon.unverified,
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'dataBreakpointUnsupported',
+                    "Data breakpoints not supported by this debug type"
+                )),
+            };
+        }
+        return {
+            icon: breakpointIcon.regular,
+            message: breakpoint$1.message || ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'dataBreakpoint',
+                "Data Breakpoint"
+            ))
+        };
+    }
+    if (breakpoint$1 instanceof FunctionBreakpoint) {
+        if (!breakpoint$1.supported) {
+            return {
+                icon: breakpointIcon.unverified,
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'functionBreakpointUnsupported',
+                    "Function breakpoints not supported by this debug type"
+                )),
+            };
+        }
+        const messages = [];
+        messages.push(breakpoint$1.message || ( localizeWithPath(
+            'vs/workbench/contrib/debug/browser/breakpointsView',
+            'functionBreakpoint',
+            "Function Breakpoint"
+        )));
+        if (breakpoint$1.condition) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'expression',
+                "Condition: {0}",
+                breakpoint$1.condition
+            )));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    '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(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'instructionBreakpointAtAddress',
+                "Instruction breakpoint at address {0}",
+                breakpoint$1.instructionReference
+            )));
+        }
+        else {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'instructionBreakpoint',
+                "Instruction breakpoint"
+            )));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'breakpointUnsupported',
+                    "Breakpoints of this type are not supported by the debugger"
+                )),
+            };
+        }
+        if (breakpoint$1.logMessage) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'logMessage',
+                "Log Message: {0}",
+                breakpoint$1.logMessage
+            )));
+        }
+        if (breakpoint$1.condition) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'expression',
+                "Condition: {0}",
+                breakpoint$1.condition
+            )));
+        }
+        if (breakpoint$1.hitCondition) {
+            messages.push(( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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) : ( localizeWithPath(
+        'vs/workbench/contrib/debug/browser/breakpointsView',
+        'breakpoint',
+        "Breakpoint"
+    ));
+    return {
+        icon: breakpointIcon.regular,
+        message
+    };
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.debug.viewlet.action.addFunctionBreakpointAction',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'addFunctionBreakpoint',
+                    "Add Function Breakpoint"
+                )),
+                original: 'Add Function Breakpoint',
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    { 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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'removeAllBreakpoints',
+                    "Remove All Breakpoints"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    { 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: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'enableAllBreakpoints',
+                    "Enable All Breakpoints"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    { 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: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    'disableAllBreakpoints',
+                    "Disable All Breakpoints"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    { 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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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', ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'editCondition',
+                "Edit Condition..."
+            )), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'condition' }))),
+                ( new Action('breakpoint.editCondition', ( localizeWithPath(
+                    'vs/workbench/contrib/debug/browser/breakpointsView',
+                    '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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                '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: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/breakpointsView',
+                'editHitCount',
+                "Edit Hit Count..."
+            )),
+            precondition: CONTEXT_BREAKPOINT_SUPPORTS_CONDITION,
+            menu: [{
+                    id: MenuId.DebugBreakpointsContext,
+                    group: 'navigation',
+                    order: 20,
+                    when: ( ContextKeyExpr.or(( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint')), ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('dataBreakpoint'))))
+                }]
+        });
+    }
+    runInView(_accessor, view, breakpoint) {
+        view.renderInputBox({ breakpoint, type: 'hitCount' });
+    }
+});
+export { BreakpointsView, getBreakpointMessageAndIcon, getExpandedBodySize, openBreakpointSource };