@codingame/monaco-vscode-api 25.1.2 → 26.0.1

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

@@ -1,11 +1,11 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { $ as $$1, isMouseEvent, append, hide, show, addStandardDisposableListener, addDisposableListener } from '../../../../base/browser/dom.js';
-import { Gesture } from '../../../../base/browser/touch.js';
 import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
 import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { IconLabel } from '../../../../base/browser/ui/iconLabel/iconLabel.js';
 import { InputBox } from '../../../../base/browser/ui/inputbox/inputBox.js';
+import { Checkbox, TriStateCheckbox } from '../../../../base/browser/ui/toggle/toggle.js';
 import '../../../../base/browser/ui/splitview/splitview.js';
 import { Action } from '../../../../base/common/actions.js';
 import { RunOnceScheduler } from '../../../../base/common/async.js';
@@ -37,7 +37,7 @@ import { WorkbenchCompressibleObjectTree } from '../../../../platform/list/brows
 import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
-import { defaultInputBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { defaultCheckboxStyles, defaultInputBoxStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { ViewPane, ViewAction } from '../../../browser/parts/views/viewPane.js';
 import { IViewDescriptorService } from '../../../common/views.service.js';
@@ -56,10 +56,9 @@ import { Orientation } from '../../../../base/browser/ui/sash/sash.js';
 var BreakpointsFolderRenderer_1, BreakpointsRenderer_1, FunctionBreakpointsRenderer_1, DataBreakpointsRenderer_1, InstructionBreakpointsRenderer_1;
 const $ = $$1;
 function createCheckbox(disposables) {
-    const checkbox = $('input');
-    checkbox.type = 'checkbox';
-    checkbox.tabIndex = -1;
-    disposables.add(Gesture.ignoreTarget(checkbox));
+    const checkbox = ( new Checkbox("", false, defaultCheckboxStyles));
+    checkbox.domNode.tabIndex = -1;
+    disposables.add(checkbox);
     return checkbox;
 }
 const MAX_VISIBLE_BREAKPOINTS = 9;
@@ -80,15 +79,43 @@ class BreakpointsFolderItem {
     }
 }
 function getModeKindForBreakpoint(breakpoint) {
-    const kind = breakpoint instanceof Breakpoint ? 'source' : breakpoint instanceof InstructionBreakpoint ? 'instruction' : 'exception';
+    const kind = breakpoint instanceof Breakpoint ? "source" : breakpoint instanceof InstructionBreakpoint ? "instruction" : "exception";
     return kind;
 }
 let BreakpointsView = class BreakpointsView extends ViewPane {
     getPresentation() {
-        return this.configurationService.getValue('debug.breakpointsView.presentation');
-    }
-    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, themeService, editorService, contextViewService, configurationService, viewDescriptorService, contextKeyService, openerService, labelService, menuService, hoverService, languageService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+        return this.configurationService.getValue("debug.breakpointsView.presentation");
+    }
+    constructor(
+        options,
+        contextMenuService,
+        debugService,
+        keybindingService,
+        instantiationService,
+        themeService,
+        editorService,
+        contextViewService,
+        configurationService,
+        viewDescriptorService,
+        contextKeyService,
+        openerService,
+        labelService,
+        menuService,
+        hoverService,
+        languageService
+    ) {
+        super(
+            options,
+            keybindingService,
+            contextMenuService,
+            configurationService,
+            contextKeyService,
+            viewDescriptorService,
+            instantiationService,
+            openerService,
+            themeService,
+            hoverService
+        );
         this.debugService = debugService;
         this.editorService = editorService;
         this.contextViewService = contextViewService;
@@ -105,106 +132,135 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
         this.breakpointHasMultipleModes = CONTEXT_BREAKPOINT_HAS_MODES.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.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');
-        this.tree = this.instantiationService.createInstance((WorkbenchCompressibleObjectTree), 'BreakpointsView', container, ( new BreakpointsDelegate(this)), [
-            this.instantiationService.createInstance(BreakpointsFolderRenderer),
-            this.instantiationService.createInstance(BreakpointsRenderer, this.menu, this.breakpointHasMultipleModes, this.breakpointSupportsCondition, this.breakpointItemType),
-            ( new ExceptionBreakpointsRenderer(
-                this.menu,
-                this.breakpointHasMultipleModes,
-                this.breakpointSupportsCondition,
-                this.breakpointItemType,
-                this.debugService,
-                this.hoverService
-            )),
-            ( 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.hoverService,
-                this.labelService
-            )),
-            this.instantiationService.createInstance(DataBreakpointsRenderer, this.menu, this.breakpointHasMultipleModes, this.breakpointSupportsCondition, this.breakpointItemType, this.breakpointIsDataBytes),
-            ( new DataBreakpointInputRenderer(
-                this,
-                this.debugService,
-                this.contextViewService,
-                this.hoverService,
-                this.labelService
-            )),
-            this.instantiationService.createInstance(InstructionBreakpointsRenderer),
-        ], {
-            compressionEnabled: this.getPresentation() === 'tree',
-            hideTwistiesOfChildlessElements: true,
-            identityProvider: {
-                getId: (element) => element.getId()
-            },
-            keyboardNavigationLabelProvider: {
-                getKeyboardNavigationLabel: (element) => {
-                    if (element instanceof BreakpointsFolderItem) {
-                        return basenameOrAuthority(element.uri);
-                    }
-                    if (element instanceof Breakpoint) {
-                        return `${basenameOrAuthority(element.uri)}:${element.lineNumber}`;
-                    }
-                    if (element instanceof FunctionBreakpoint) {
-                        return element.name;
-                    }
-                    if (element instanceof DataBreakpoint) {
-                        return element.description;
-                    }
-                    if (element instanceof ExceptionBreakpoint) {
-                        return element.label || element.filter;
-                    }
-                    if (element instanceof InstructionBreakpoint) {
-                        return `0x${( element.address.toString(16))}`;
-                    }
-                    return '';
+        this.element.classList.add("debug-pane");
+        container.classList.add("debug-breakpoints");
+        this.tree = this.instantiationService.createInstance(
+            WorkbenchCompressibleObjectTree,
+            "BreakpointsView",
+            container,
+            ( new BreakpointsDelegate(this)),
+            [
+                this.instantiationService.createInstance(BreakpointsFolderRenderer),
+                this.instantiationService.createInstance(
+                    BreakpointsRenderer,
+                    this.menu,
+                    this.breakpointHasMultipleModes,
+                    this.breakpointSupportsCondition,
+                    this.breakpointItemType
+                ),
+                ( new ExceptionBreakpointsRenderer(
+                    this.menu,
+                    this.breakpointHasMultipleModes,
+                    this.breakpointSupportsCondition,
+                    this.breakpointItemType,
+                    this.debugService,
+                    this.hoverService
+                )),
+                ( 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.hoverService,
+                    this.labelService
+                )),
+                this.instantiationService.createInstance(
+                    DataBreakpointsRenderer,
+                    this.menu,
+                    this.breakpointHasMultipleModes,
+                    this.breakpointSupportsCondition,
+                    this.breakpointItemType,
+                    this.breakpointIsDataBytes
+                ),
+                ( new DataBreakpointInputRenderer(
+                    this,
+                    this.debugService,
+                    this.contextViewService,
+                    this.hoverService,
+                    this.labelService
+                )),
+                this.instantiationService.createInstance(InstructionBreakpointsRenderer)
+            ],
+            {
+                compressionEnabled: this.getPresentation() === "tree",
+                hideTwistiesOfChildlessElements: true,
+                identityProvider: {
+                    getId: element => element.getId()
                 },
-                getCompressedNodeKeyboardNavigationLabel: (elements) => {
-                    return ( elements.map(e => {
-                        if (e instanceof BreakpointsFolderItem) {
-                            return basenameOrAuthority(e.uri);
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: element => {
+                        if (element instanceof BreakpointsFolderItem) {
+                            return basenameOrAuthority(element.uri);
                         }
-                        return '';
-                    })).join('/');
-                }
-            },
-            accessibilityProvider: ( new BreakpointsAccessibilityProvider(this.debugService, this.labelService)),
-            multipleSelectionSupport: false,
-            overrideStyles: this.getLocationBasedColors().listOverrideStyles
-        });
+                        if (element instanceof Breakpoint) {
+                            return `${basenameOrAuthority(element.uri)}:${element.lineNumber}`;
+                        }
+                        if (element instanceof FunctionBreakpoint) {
+                            return element.name;
+                        }
+                        if (element instanceof DataBreakpoint) {
+                            return element.description;
+                        }
+                        if (element instanceof ExceptionBreakpoint) {
+                            return element.label || element.filter;
+                        }
+                        if (element instanceof InstructionBreakpoint) {
+                            return `0x${( element.address.toString(16))}`;
+                        }
+                        return "";
+                    },
+                    getCompressedNodeKeyboardNavigationLabel: elements => {
+                        return ( elements.map(e => {
+                            if (e instanceof BreakpointsFolderItem) {
+                                return basenameOrAuthority(e.uri);
+                            }
+                            return "";
+                        })).join("/");
+                    }
+                },
+                accessibilityProvider: ( new BreakpointsAccessibilityProvider(this.debugService, this.labelService)),
+                multipleSelectionSupport: false,
+                overrideStyles: this.getLocationBasedColors().listOverrideStyles
+            }
+        );
         this._register(this.tree);
         CONTEXT_BREAKPOINTS_FOCUSED.bindTo(this.tree.contextKeyService);
         this._register(this.tree.onContextMenu(this.onTreeContextMenu, this));
-        this._register(this.tree.onMouseMiddleClick(async ({ element }) => {
+        this._register(this.tree.onMouseMiddleClick(async (
+            {
+                element
+            }
+        ) => {
             if (element instanceof Breakpoint) {
                 await this.debugService.removeBreakpoints(element.getId());
-            }
-            else if (element instanceof FunctionBreakpoint) {
+            } else if (element instanceof FunctionBreakpoint) {
                 await this.debugService.removeFunctionBreakpoints(element.getId());
-            }
-            else if (element instanceof DataBreakpoint) {
+            } else if (element instanceof DataBreakpoint) {
                 await this.debugService.removeDataBreakpoints(element.getId());
-            }
-            else if (element instanceof InstructionBreakpoint) {
+            } else if (element instanceof InstructionBreakpoint) {
                 await this.debugService.removeInstructionBreakpoints(element.instructionReference, element.offset);
-            }
-            else if (element instanceof BreakpointsFolderItem) {
+            } else if (element instanceof BreakpointsFolderItem) {
                 await this.debugService.removeBreakpoints(( element.breakpoints.map(bp => bp.getId())));
             }
         }));
-        this._register(this.tree.onDidOpen(async (e) => {
+        this._register(this.tree.onDidOpen(async e => {
             const element = e.element;
             if (!element) {
                 return;
@@ -213,14 +269,28 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
                 return;
             }
             if (element instanceof Breakpoint) {
-                openBreakpointSource(element, e.sideBySide, e.editorOptions.preserveFocus || false, e.editorOptions.pinned || !e.editorOptions.preserveFocus, this.debugService, this.editorService);
+                openBreakpointSource(
+                    element,
+                    e.sideBySide,
+                    e.editorOptions.preserveFocus || false,
+                    e.editorOptions.pinned || !e.editorOptions.preserveFocus,
+                    this.debugService,
+                    this.editorService
+                );
             }
             if (element instanceof InstructionBreakpoint) {
                 const disassemblyView = await this.editorService.openEditor(DisassemblyViewInput.instance);
-                disassemblyView.goToInstructionAndOffset(element.instructionReference, element.offset, isMouseEvent(e.browserEvent) && e.browserEvent.detail === 2);
+                disassemblyView.goToInstructionAndOffset(
+                    element.instructionReference,
+                    element.offset,
+                    isMouseEvent(e.browserEvent) && e.browserEvent.detail === 2
+                );
             }
             if (isMouseEvent(e.browserEvent) && e.browserEvent.detail === 2 && element instanceof FunctionBreakpoint && element !== this.inputBoxData?.breakpoint) {
-                this.renderInputBox({ breakpoint: element, type: 'name' });
+                this.renderInputBox({
+                    breakpoint: element,
+                    type: "name"
+                });
             }
         }));
         this._register(this.tree.onDidChangeCollapseState(e => {
@@ -228,17 +298,18 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
             if (element instanceof BreakpointsFolderItem) {
                 if (e.node.collapsed) {
                     this.collapsedState.add(element.getId());
-                }
-                else {
+                } else {
                     this.collapsedState.delete(element.getId());
                 }
                 this.updateSize();
             }
         }));
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('debug.breakpointsView.presentation')) {
+            if (e.affectsConfiguration("debug.breakpointsView.presentation")) {
                 const presentation = this.getPresentation();
-                this.tree.updateOptions({ compressionEnabled: presentation === 'tree' });
+                this.tree.updateOptions({
+                    compressionEnabled: presentation === "tree"
+                });
                 this.onBreakpointsChange();
             }
         }));
@@ -260,11 +331,15 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
     }
     renderHeaderTitle(container, title) {
         super.renderHeaderTitle(container, title);
-        const iconLabelContainer = append(container, $('span.breakpoint-warning'));
+        const iconLabelContainer = append(container, $("span.breakpoint-warning"));
         this.hintContainer = this._register(( new IconLabel(iconLabelContainer, {
-            supportIcons: true, hoverDelegate: {
-                showHover: (options, focus) => this.hoverService.showInstantHover({ content: options.content, target: this.hintContainer.element }, focus),
-                delay: this.configurationService.getValue('workbench.hover.delay')
+            supportIcons: true,
+            hoverDelegate: {
+                showHover: (options, focus) => this.hoverService.showInstantHover({
+                    content: options.content,
+                    target: this.hintContainer.element
+                }, focus),
+                delay: this.configurationService.getValue("workbench.hover.delay")
             }
         })));
         hide(this.hintContainer.element);
@@ -290,16 +365,20 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
         try {
             this.ignoreLayout = true;
             this.updateSize();
-        }
-        finally {
+        } finally {
             this.ignoreLayout = false;
         }
     }
     onTreeContextMenu(e) {
         const element = e.element;
         if (element instanceof BreakpointsFolderItem) {
-            this.breakpointItemType.set('breakpointFolder');
-            const { secondary } = getContextMenuActions(this.menu.getActions({ arg: element, shouldForwardArgs: false }), 'inline');
+            this.breakpointItemType.set("breakpointFolder");
+            const {
+                secondary
+            } = getContextMenuActions(this.menu.getActions({
+                arg: element,
+                shouldForwardArgs: false
+            }), "inline");
             this.contextMenuService.showContextMenu({
                 getAnchor: () => e.anchor,
                 getActions: () => secondary,
@@ -307,16 +386,23 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
             });
             return;
         }
-        const type = element instanceof Breakpoint ? 'breakpoint' : element instanceof ExceptionBreakpoint ? 'exceptionBreakpoint' :
-            element instanceof FunctionBreakpoint ? 'functionBreakpoint' : element instanceof DataBreakpoint ? 'dataBreakpoint' :
-                element instanceof InstructionBreakpoint ? 'instructionBreakpoint' : undefined;
+        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);
-        this.breakpointIsDataBytes.set(element instanceof DataBreakpoint && element.src.type === DataBreakpointSetType.Address);
-        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes(getModeKindForBreakpoint(element)).length > 1);
-        const { secondary } = getContextMenuActions(this.menu.getActions({ arg: e.element, shouldForwardArgs: false }), 'inline');
+        this.breakpointIsDataBytes.set(
+            element instanceof DataBreakpoint && element.src.type === DataBreakpointSetType.Address
+        );
+        this.breakpointHasMultipleModes.set(
+            this.debugService.getModel().getBreakpointModes(getModeKindForBreakpoint(element)).length > 1
+        );
+        const {
+            secondary
+        } = getContextMenuActions(this.menu.getActions({
+            arg: e.element,
+            shouldForwardArgs: false
+        }), "inline");
         this.contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
             getActions: () => secondary,
@@ -345,15 +431,20 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
         });
         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 } });
+                const mdown = ( new MarkdownString(undefined, {
+                    isTrusted: true
+                })).appendMarkdown(message);
+                this.hintContainer.setLabel("$(warning)", undefined, {
+                    title: {
+                        markdown: mdown,
+                        markdownNotSupportedFallback: message
+                    }
+                });
                 show(this.hintContainer.element);
-            }
-            else {
+            } else {
                 this.hintDelayer.schedule();
             }
-        }
-        else {
+        } else {
             hide(this.hintContainer.element);
         }
     }
@@ -365,8 +456,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
             }
             this.updateBreakpointsHint();
             this.updateSize();
-        }
-        else {
+        } else {
             this.needsRefresh = true;
         }
     }
@@ -380,7 +470,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
                 const elements = this.flatElements;
                 const hitElement = elements.find(e => {
                     const id = e.getIdFromAdapter(thread.session.getId());
-                    return typeof id === 'number' && hitBreakpointIds.indexOf(id) !== -1;
+                    return typeof id === "number" && hitBreakpointIds.indexOf(id) !== -1;
                 });
                 if (hitElement) {
                     this.tree.setFocus([hitElement]);
@@ -399,8 +489,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
                 this.autoFocusedElement = undefined;
             }
             this.updateBreakpointsHint();
-        }
-        else {
+        } else {
             this.needsStateChange = true;
         }
     }
@@ -411,16 +500,25 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
     getTreeElements() {
         const model = this.debugService.getModel();
         const sessionId = this.debugService.getViewModel().focusedSession?.getId();
-        const showAsTree = this.getPresentation() === 'tree';
+        const showAsTree = this.getPresentation() === "tree";
         const result = [];
         for (const exBp of model.getExceptionBreakpointsForSession(sessionId)) {
-            result.push({ element: exBp, incompressible: true });
+            result.push({
+                element: exBp,
+                incompressible: true
+            });
         }
         for (const funcBp of model.getFunctionBreakpoints()) {
-            result.push({ element: funcBp, incompressible: true });
+            result.push({
+                element: funcBp,
+                incompressible: true
+            });
         }
         for (const dataBp of model.getDataBreakpoints()) {
-            result.push({ element: dataBp, incompressible: true });
+            result.push({
+                element: dataBp,
+                incompressible: true
+            });
         }
         const sourceBreakpoints = model.getBreakpoints();
         if (showAsTree && sourceBreakpoints.length > 0) {
@@ -443,22 +541,23 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
                 result.push({
                     element: folderItem,
                     incompressible: false,
-                    collapsed: ( this.collapsedState.has(folderItem.getId())) || !( this.collapsedState.has(`_init_${folderItem.getId()}`)),
+                    collapsed: ( this.collapsedState.has(folderItem.getId())),
                     children
                 });
-                if (!( this.collapsedState.has(`_init_${folderItem.getId()}`))) {
-                    this.collapsedState.add(`_init_${folderItem.getId()}`);
-                    this.collapsedState.add(folderItem.getId());
-                }
             }
-        }
-        else {
+        } else {
             for (const bp of sourceBreakpoints) {
-                result.push({ element: bp, incompressible: true });
+                result.push({
+                    element: bp,
+                    incompressible: true
+                });
             }
         }
         for (const instrBp of model.getInstructionBreakpoints()) {
-            result.push({ element: instrBp, incompressible: true });
+            result.push({
+                element: instrBp,
+                incompressible: true
+            });
         }
         return result;
     }
@@ -469,23 +568,7 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
         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, ILabelService)),
-    ( __param(13, IMenuService)),
-    ( __param(14, IHoverService)),
-    ( __param(15, ILanguageService))
-], BreakpointsView));
+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, ILabelService)), ( __param(13, IMenuService)), ( __param(14, IHoverService)), ( __param(15, ILanguageService))], BreakpointsView));
 class BreakpointsDelegate {
     constructor(view) {
         this.view = view;
@@ -524,13 +607,17 @@ class BreakpointsDelegate {
         if (element instanceof InstructionBreakpoint) {
             return InstructionBreakpointsRenderer.ID;
         }
-        return '';
+        return "";
     }
 }
 const breakpointIdToActionBarDomeNode = ( new Map());
 let BreakpointsFolderRenderer = class BreakpointsFolderRenderer {
-    static { BreakpointsFolderRenderer_1 = this; }
-    static { this.ID = 'breakpointFolder'; }
+    static {
+        BreakpointsFolderRenderer_1 = this;
+    }
+    static {
+        this.ID = "breakpointFolder";
+    }
     constructor(debugService, labelService, hoverService) {
         this.debugService = debugService;
         this.labelService = labelService;
@@ -545,20 +632,23 @@ let BreakpointsFolderRenderer = class BreakpointsFolderRenderer {
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
         data.container = container;
-        container.classList.add('breakpoint', 'breakpoint-folder');
+        container.classList.add("breakpoint", "breakpoint-folder");
         data.templateDisposables.add(toDisposable(() => {
-            container.classList.remove('breakpoint', 'breakpoint-folder');
+            container.classList.remove("breakpoint", "breakpoint-folder");
         }));
-        data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
-            const enabled = data.checkbox.checked;
+        data.checkbox = ( new TriStateCheckbox("", false, defaultCheckboxStyles));
+        data.checkbox.domNode.tabIndex = -1;
+        data.templateDisposables.add(data.checkbox);
+        data.templateDisposables.add(data.checkbox.onChange(() => {
+            const checked = data.checkbox.checked;
+            const enabled = checked === "mixed" ? true : checked;
             for (const bp of data.context.breakpoints) {
                 this.debugService.enableOrDisableBreakpoints(enabled, bp);
             }
         }));
-        append(data.container, data.checkbox);
-        data.name = append(data.container, $('span.name'));
-        append(data.container, $('span.file-path'));
+        append(data.container, data.checkbox.domNode);
+        data.name = append(data.container, $("span.name"));
+        append(data.container, $("span.file-path"));
         data.actionBar = ( new ActionBar(data.container));
         data.templateDisposables.add(data.actionBar);
         return data;
@@ -567,48 +657,56 @@ let BreakpointsFolderRenderer = class BreakpointsFolderRenderer {
         const folderItem = node.element;
         data.context = folderItem;
         data.name.textContent = this.labelService.getUriBasenameLabel(folderItem.uri);
-        data.container.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
-        const fullPath = this.labelService.getUriLabel(folderItem.uri, { relative: true });
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.container, fullPath));
+        data.container.classList.toggle("disabled", !this.debugService.getModel().areBreakpointsActivated());
+        const fullPath = this.labelService.getUriLabel(folderItem.uri, {
+            relative: true
+        });
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.container, fullPath)
+        );
         if (folderItem.indeterminate) {
-            data.checkbox.checked = false;
-            data.checkbox.indeterminate = true;
-        }
-        else {
-            data.checkbox.indeterminate = false;
+            data.checkbox.checked = "mixed";
+        } else {
             data.checkbox.checked = folderItem.enabled;
         }
         data.actionBar.clear();
-        const removeAction = data.elementDisposables.add(( new Action('debug.removeBreakpointsInFile', ( localize(6495, "Remove Breakpoints in File")), ThemeIcon.asClassName(Codicon.close), true, async () => {
+        const removeAction = data.elementDisposables.add(( new Action("debug.removeBreakpointsInFile", ( localize(6805, "Remove Breakpoints in File")), ThemeIcon.asClassName(Codicon.close), true, async () => {
             for (const bp of folderItem.breakpoints) {
                 await this.debugService.removeBreakpoints(bp.getId());
             }
         })));
-        data.actionBar.push(removeAction, { icon: true, label: false });
+        data.actionBar.push(removeAction, {
+            icon: true,
+            label: false
+        });
     }
     renderCompressedElements(node, _index, data) {
         const elements = node.element.elements;
         const folderItem = elements[elements.length - 1];
         data.context = folderItem;
         const names = ( elements.map(e => basenameOrAuthority(e.uri)));
-        data.name.textContent = names.join('/');
-        const fullPath = this.labelService.getUriLabel(folderItem.uri, { relative: true });
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.container, fullPath));
+        data.name.textContent = names.join("/");
+        const fullPath = this.labelService.getUriLabel(folderItem.uri, {
+            relative: true
+        });
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.container, fullPath)
+        );
         if (folderItem.indeterminate) {
-            data.checkbox.checked = false;
-            data.checkbox.indeterminate = true;
-        }
-        else {
-            data.checkbox.indeterminate = false;
+            data.checkbox.checked = "mixed";
+        } else {
             data.checkbox.checked = folderItem.enabled;
         }
         data.actionBar.clear();
-        const removeAction = data.elementDisposables.add(( new Action('debug.removeBreakpointsInFile', ( localize(6495, "Remove Breakpoints in File")), ThemeIcon.asClassName(Codicon.close), true, async () => {
+        const removeAction = data.elementDisposables.add(( new Action("debug.removeBreakpointsInFile", ( localize(6805, "Remove Breakpoints in File")), ThemeIcon.asClassName(Codicon.close), true, async () => {
             for (const bp of folderItem.breakpoints) {
                 await this.debugService.removeBreakpoints(bp.getId());
             }
         })));
-        data.actionBar.push(removeAction, { icon: true, label: false });
+        data.actionBar.push(removeAction, {
+            icon: true,
+            label: false
+        });
     }
     disposeElement(element, index, templateData) {
         templateData.elementDisposables.clear();
@@ -620,14 +718,21 @@ let BreakpointsFolderRenderer = class BreakpointsFolderRenderer {
         templateData.templateDisposables.dispose();
     }
 };
-BreakpointsFolderRenderer = BreakpointsFolderRenderer_1 = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, ILabelService)),
-    ( __param(2, IHoverService))
-], BreakpointsFolderRenderer));
+BreakpointsFolderRenderer = BreakpointsFolderRenderer_1 = ( __decorate([( __param(0, IDebugService)), ( __param(1, ILabelService)), ( __param(2, IHoverService))], BreakpointsFolderRenderer));
 let BreakpointsRenderer = class BreakpointsRenderer {
-    static { BreakpointsRenderer_1 = this; }
-    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService, hoverService, labelService, textModelService) {
+    static {
+        BreakpointsRenderer_1 = this;
+    }
+    constructor(
+        menu,
+        breakpointHasMultipleModes,
+        breakpointSupportsCondition,
+        breakpointItemType,
+        debugService,
+        hoverService,
+        labelService,
+        textModelService
+    ) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
@@ -637,7 +742,9 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         this.labelService = labelService;
         this.textModelService = textModelService;
     }
-    static { this.ID = 'breakpoints'; }
+    static {
+        this.ID = "breakpoints";
+    }
     get templateId() {
         return BreakpointsRenderer_1.ID;
     }
@@ -647,23 +754,23 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
         data.breakpoint = container;
-        container.classList.add('breakpoint');
+        container.classList.add("breakpoint");
         data.templateDisposables.add(toDisposable(() => {
-            container.classList.remove('breakpoint');
+            container.classList.remove("breakpoint");
         }));
-        data.icon = $('.icon');
+        data.icon = $(".icon");
         data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
+        data.templateDisposables.add(data.checkbox.onChange(() => {
             this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
         }));
         append(data.breakpoint, data.icon);
-        append(data.breakpoint, data.checkbox);
-        data.name = append(data.breakpoint, $('span.name'));
-        data.filePath = append(data.breakpoint, $('span.file-path'));
+        append(data.breakpoint, data.checkbox.domNode);
+        data.name = append(data.breakpoint, $("span.name"));
+        data.filePath = append(data.breakpoint, $("span.file-path"));
         data.actionBar = ( new ActionBar(data.breakpoint));
         data.templateDisposables.add(data.actionBar);
-        const badgeContainer = append(data.breakpoint, $('.badge-container'));
-        data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
+        const badgeContainer = append(data.breakpoint, $(".badge-container"));
+        data.badge = append(badgeContainer, $("span.line-number.monaco-count-badge"));
         return data;
     }
     renderElement(node, index, data) {
@@ -671,8 +778,7 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         data.context = breakpoint;
         if (node.depth > 1) {
             this.renderBreakpointLineLabel(breakpoint, data);
-        }
-        else {
+        } else {
             this.renderBreakpointFileLabel(breakpoint, data);
         }
         this.renderBreakpointCommon(breakpoint, data);
@@ -684,7 +790,7 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         this.renderBreakpointCommon(breakpoint, data);
     }
     renderBreakpointCommon(breakpoint, data) {
-        data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
+        data.breakpoint.classList.toggle("disabled", !this.debugService.getModel().areBreakpointsActivated());
         let badgeContent = ( breakpoint.lineNumber.toString());
         if (breakpoint.column) {
             badgeContent += `:${breakpoint.column}`;
@@ -694,29 +800,52 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         }
         data.badge.textContent = badgeContent;
         data.checkbox.checked = breakpoint.enabled;
-        const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService, this.debugService.getModel());
+        const {
+            message,
+            icon
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            breakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
+        data.elementDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("mouse"),
+            data.breakpoint,
+            breakpoint.message || message || ""
+        ));
         const debugActive = this.debugService.state === State.Running || this.debugService.state === State.Stopped;
         if (debugActive && !breakpoint.verified) {
-            data.breakpoint.classList.add('disabled');
+            data.breakpoint.classList.add("disabled");
         }
         const session = this.debugService.getViewModel().focusedSession;
         this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
-        this.breakpointItemType.set('breakpoint');
-        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes('source').length > 1);
-        const { primary } = getActionBarActions(this.menu.getActions({ arg: breakpoint, shouldForwardArgs: true }), 'inline');
+        this.breakpointItemType.set("breakpoint");
+        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes("source").length > 1);
+        const {
+            primary
+        } = getActionBarActions(this.menu.getActions({
+            arg: breakpoint,
+            shouldForwardArgs: true
+        }), "inline");
         data.actionBar.clear();
-        data.actionBar.push(primary, { icon: true, label: false });
+        data.actionBar.push(primary, {
+            icon: true,
+            label: false
+        });
         breakpointIdToActionBarDomeNode.set(breakpoint.getId(), data.actionBar.domNode);
     }
     renderBreakpointFileLabel(breakpoint, data) {
         data.name.textContent = basenameOrAuthority(breakpoint.uri);
-        data.filePath.textContent = this.labelService.getUriLabel(dirname(breakpoint.uri), { relative: true });
+        data.filePath.textContent = this.labelService.getUriLabel(dirname(breakpoint.uri), {
+            relative: true
+        });
     }
     renderBreakpointLineLabel(breakpoint, data) {
-        data.name.textContent = ( localize(6496, "Loading..."));
-        data.filePath.textContent = '';
+        data.name.textContent = ( localize(6806, "Loading..."));
+        data.filePath.textContent = "";
         this.textModelService.createModelReference(breakpoint.uri).then(reference => {
             if (data.context !== breakpoint) {
                 reference.dispose();
@@ -726,14 +855,13 @@ let BreakpointsRenderer = class BreakpointsRenderer {
             const model = reference.object.textEditorModel;
             if (model && breakpoint.lineNumber <= model.getLineCount()) {
                 const lineContent = model.getLineContent(breakpoint.lineNumber).trim();
-                data.name.textContent = lineContent || ( localize(6497, "(empty line)"));
-            }
-            else {
-                data.name.textContent = ( localize(6498, "(line not found)"));
+                data.name.textContent = lineContent || ( localize(6807, "(empty line)"));
+            } else {
+                data.name.textContent = ( localize(6808, "(line not found)"));
             }
         }).catch(() => {
             if (data.context === breakpoint) {
-                data.name.textContent = ( localize(6499, "(cannot load line)"));
+                data.name.textContent = ( localize(6809, "(cannot load line)"));
             }
         });
     }
@@ -747,14 +875,16 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         templateData.templateDisposables.dispose();
     }
 };
-BreakpointsRenderer = BreakpointsRenderer_1 = ( __decorate([
-    ( __param(4, IDebugService)),
-    ( __param(5, IHoverService)),
-    ( __param(6, ILabelService)),
-    ( __param(7, ITextModelService))
-], BreakpointsRenderer));
+BreakpointsRenderer = BreakpointsRenderer_1 = ( __decorate([( __param(4, IDebugService)), ( __param(5, IHoverService)), ( __param(6, ILabelService)), ( __param(7, ITextModelService))], BreakpointsRenderer));
 class ExceptionBreakpointsRenderer {
-    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService, hoverService) {
+    constructor(
+        menu,
+        breakpointHasMultipleModes,
+        breakpointSupportsCondition,
+        breakpointItemType,
+        debugService,
+        hoverService
+    ) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
@@ -762,7 +892,9 @@ class ExceptionBreakpointsRenderer {
         this.debugService = debugService;
         this.hoverService = hoverService;
     }
-    static { this.ID = 'exceptionbreakpoints'; }
+    static {
+        this.ID = "exceptionbreakpoints";
+    }
     get templateId() {
         return ExceptionBreakpointsRenderer.ID;
     }
@@ -771,19 +903,19 @@ class ExceptionBreakpointsRenderer {
         data.elementDisposables = ( new DisposableStore());
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
-        data.breakpoint = append(container, $('.breakpoint'));
+        data.breakpoint = append(container, $(".breakpoint"));
         data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
+        data.templateDisposables.add(data.checkbox.onChange(() => {
             this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
         }));
-        append(data.breakpoint, data.checkbox);
-        data.name = append(data.breakpoint, $('span.name'));
-        data.condition = append(data.breakpoint, $('span.condition'));
-        data.breakpoint.classList.add('exception');
+        append(data.breakpoint, data.checkbox.domNode);
+        data.name = append(data.breakpoint, $("span.name"));
+        data.condition = append(data.breakpoint, $("span.condition"));
+        data.breakpoint.classList.add("exception");
         data.actionBar = ( new ActionBar(data.breakpoint));
         data.templateDisposables.add(data.actionBar);
-        const badgeContainer = append(data.breakpoint, $('.badge-container'));
-        data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
+        const badgeContainer = append(data.breakpoint, $(".badge-container"));
+        data.badge = append(badgeContainer, $("span.line-number.monaco-count-badge"));
         return data;
     }
     renderElement(node, index, data) {
@@ -797,25 +929,38 @@ class ExceptionBreakpointsRenderer {
     renderExceptionBreakpoint(exceptionBreakpoint, data) {
         data.context = exceptionBreakpoint;
         data.name.textContent = exceptionBreakpoint.label || `${exceptionBreakpoint.filter} exceptions`;
-        const exceptionBreakpointtitle = exceptionBreakpoint.verified ? (exceptionBreakpoint.description || data.name.textContent) : exceptionBreakpoint.message || ( localize(6500, "Unverified Exception Breakpoint"));
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, exceptionBreakpointtitle));
-        data.breakpoint.classList.toggle('disabled', !exceptionBreakpoint.verified);
+        const exceptionBreakpointtitle = exceptionBreakpoint.verified ? (exceptionBreakpoint.description || data.name.textContent) : exceptionBreakpoint.message || ( localize(6810, "Unverified Exception Breakpoint"));
+        data.elementDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("mouse"),
+            data.breakpoint,
+            exceptionBreakpointtitle
+        ));
+        data.breakpoint.classList.toggle("disabled", !exceptionBreakpoint.verified);
         data.checkbox.checked = exceptionBreakpoint.enabled;
-        data.condition.textContent = exceptionBreakpoint.condition || '';
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.condition, ( localize(6501, "Expression condition: {0}", exceptionBreakpoint.condition))));
+        data.condition.textContent = exceptionBreakpoint.condition || "";
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.condition, ( localize(6811, "Expression condition: {0}", exceptionBreakpoint.condition)))
+        );
         if (exceptionBreakpoint.modeLabel) {
             data.badge.textContent = exceptionBreakpoint.modeLabel;
-            data.badge.style.display = 'block';
-        }
-        else {
-            data.badge.style.display = 'none';
+            data.badge.style.display = "block";
+        } else {
+            data.badge.style.display = "none";
         }
         this.breakpointSupportsCondition.set(exceptionBreakpoint.supportsCondition);
-        this.breakpointItemType.set('exceptionBreakpoint');
-        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes('exception').length > 1);
-        const { primary } = getActionBarActions(this.menu.getActions({ arg: exceptionBreakpoint, shouldForwardArgs: true }), 'inline');
+        this.breakpointItemType.set("exceptionBreakpoint");
+        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes("exception").length > 1);
+        const {
+            primary
+        } = getActionBarActions(this.menu.getActions({
+            arg: exceptionBreakpoint,
+            shouldForwardArgs: true
+        }), "inline");
         data.actionBar.clear();
-        data.actionBar.push(primary, { icon: true, label: false });
+        data.actionBar.push(primary, {
+            icon: true,
+            label: false
+        });
         breakpointIdToActionBarDomeNode.set(exceptionBreakpoint.getId(), data.actionBar.domNode);
     }
     disposeElement(node, index, templateData) {
@@ -829,8 +974,17 @@ class ExceptionBreakpointsRenderer {
     }
 }
 let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
-    static { FunctionBreakpointsRenderer_1 = this; }
-    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, hoverService, labelService) {
+    static {
+        FunctionBreakpointsRenderer_1 = this;
+    }
+    constructor(
+        menu,
+        breakpointSupportsCondition,
+        breakpointItemType,
+        debugService,
+        hoverService,
+        labelService
+    ) {
         this.menu = menu;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
         this.breakpointItemType = breakpointItemType;
@@ -838,7 +992,9 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         this.hoverService = hoverService;
         this.labelService = labelService;
     }
-    static { this.ID = 'functionbreakpoints'; }
+    static {
+        this.ID = "functionbreakpoints";
+    }
     get templateId() {
         return FunctionBreakpointsRenderer_1.ID;
     }
@@ -847,20 +1003,20 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         data.elementDisposables = ( new DisposableStore());
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
-        data.breakpoint = append(container, $('.breakpoint'));
-        data.icon = $('.icon');
+        data.breakpoint = append(container, $(".breakpoint"));
+        data.icon = $(".icon");
         data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
+        data.templateDisposables.add(data.checkbox.onChange(() => {
             this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
         }));
         append(data.breakpoint, data.icon);
-        append(data.breakpoint, data.checkbox);
-        data.name = append(data.breakpoint, $('span.name'));
-        data.condition = append(data.breakpoint, $('span.condition'));
+        append(data.breakpoint, data.checkbox.domNode);
+        data.name = append(data.breakpoint, $("span.name"));
+        data.condition = append(data.breakpoint, $("span.condition"));
         data.actionBar = ( new ActionBar(data.breakpoint));
         data.templateDisposables.add(data.actionBar);
-        const badgeContainer = append(data.breakpoint, $('.badge-container'));
-        data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
+        const badgeContainer = append(data.breakpoint, $(".badge-container"));
+        data.badge = append(badgeContainer, $("span.line-number.monaco-count-badge"));
         return data;
     }
     renderElement(node, _index, data) {
@@ -872,39 +1028,63 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
     renderFunctionBreakpoint(functionBreakpoint, data) {
         data.context = functionBreakpoint;
         data.name.textContent = functionBreakpoint.name;
-        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), functionBreakpoint, this.labelService, this.debugService.getModel());
+        const {
+            icon,
+            message
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            functionBreakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.icon, message ? message : "")
+        );
         data.checkbox.checked = functionBreakpoint.enabled;
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.breakpoint, message ? message : "")
+        );
         if (functionBreakpoint.condition && functionBreakpoint.hitCondition) {
             data.condition.textContent = ( localize(
-                6502,
+                6812,
                 "Condition: {0} | Hit Count: {1}",
                 functionBreakpoint.condition,
                 functionBreakpoint.hitCondition
             ));
-        }
-        else {
-            data.condition.textContent = functionBreakpoint.condition || functionBreakpoint.hitCondition || '';
+        } else {
+            data.condition.textContent = functionBreakpoint.condition || functionBreakpoint.hitCondition || "";
         }
         if (functionBreakpoint.modeLabel) {
             data.badge.textContent = functionBreakpoint.modeLabel;
-            data.badge.style.display = 'block';
-        }
-        else {
-            data.badge.style.display = 'none';
+            data.badge.style.display = "block";
+        } else {
+            data.badge.style.display = "none";
         }
         const session = this.debugService.getViewModel().focusedSession;
-        data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsFunctionBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
+        data.breakpoint.classList.toggle(
+            "disabled",
+            (session && !session.capabilities.supportsFunctionBreakpoints) || !this.debugService.getModel().areBreakpointsActivated()
+        );
         if (session && !session.capabilities.supportsFunctionBreakpoints) {
-            data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localize(6503, "Function breakpoints are not supported by this debug type"))));
+            data.elementDisposables.add(
+                this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.breakpoint, ( localize(6813, "Function breakpoints are not supported by this debug type")))
+            );
         }
         this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
-        this.breakpointItemType.set('functionBreakpoint');
-        const { primary } = getActionBarActions(this.menu.getActions({ arg: functionBreakpoint, shouldForwardArgs: true }), 'inline');
+        this.breakpointItemType.set("functionBreakpoint");
+        const {
+            primary
+        } = getActionBarActions(this.menu.getActions({
+            arg: functionBreakpoint,
+            shouldForwardArgs: true
+        }), "inline");
         data.actionBar.clear();
-        data.actionBar.push(primary, { icon: true, label: false });
+        data.actionBar.push(primary, {
+            icon: true,
+            label: false
+        });
         breakpointIdToActionBarDomeNode.set(functionBreakpoint.getId(), data.actionBar.domNode);
     }
     disposeElement(node, index, templateData) {
@@ -917,14 +1097,21 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         templateData.templateDisposables.dispose();
     }
 };
-FunctionBreakpointsRenderer = FunctionBreakpointsRenderer_1 = ( __decorate([
-    ( __param(3, IDebugService)),
-    ( __param(4, IHoverService)),
-    ( __param(5, ILabelService))
-], FunctionBreakpointsRenderer));
+FunctionBreakpointsRenderer = FunctionBreakpointsRenderer_1 = ( __decorate([( __param(3, IDebugService)), ( __param(4, IHoverService)), ( __param(5, ILabelService))], FunctionBreakpointsRenderer));
 let DataBreakpointsRenderer = class DataBreakpointsRenderer {
-    static { DataBreakpointsRenderer_1 = this; }
-    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, breakpointIsDataBytes, debugService, hoverService, labelService) {
+    static {
+        DataBreakpointsRenderer_1 = this;
+    }
+    constructor(
+        menu,
+        breakpointHasMultipleModes,
+        breakpointSupportsCondition,
+        breakpointItemType,
+        breakpointIsDataBytes,
+        debugService,
+        hoverService,
+        labelService
+    ) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
@@ -934,30 +1121,32 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         this.hoverService = hoverService;
         this.labelService = labelService;
     }
-    static { this.ID = 'databreakpoints'; }
+    static {
+        this.ID = "databreakpoints";
+    }
     get templateId() {
         return DataBreakpointsRenderer_1.ID;
     }
     renderTemplate(container) {
         const data = Object.create(null);
-        data.breakpoint = append(container, $('.breakpoint'));
+        data.breakpoint = append(container, $(".breakpoint"));
         data.elementDisposables = ( new DisposableStore());
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
-        data.icon = $('.icon');
+        data.icon = $(".icon");
         data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
+        data.templateDisposables.add(data.checkbox.onChange(() => {
             this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
         }));
         append(data.breakpoint, data.icon);
-        append(data.breakpoint, data.checkbox);
-        data.name = append(data.breakpoint, $('span.name'));
-        data.accessType = append(data.breakpoint, $('span.access-type'));
-        data.condition = append(data.breakpoint, $('span.condition'));
+        append(data.breakpoint, data.checkbox.domNode);
+        data.name = append(data.breakpoint, $("span.name"));
+        data.accessType = append(data.breakpoint, $("span.access-type"));
+        data.condition = append(data.breakpoint, $("span.condition"));
         data.actionBar = ( new ActionBar(data.breakpoint));
         data.templateDisposables.add(data.actionBar);
-        const badgeContainer = append(data.breakpoint, $('.badge-container'));
-        data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
+        const badgeContainer = append(data.breakpoint, $(".badge-container"));
+        data.badge = append(badgeContainer, $("span.line-number.monaco-count-badge"));
         return data;
     }
     renderElement(node, _index, data) {
@@ -969,48 +1158,71 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
     renderDataBreakpoint(dataBreakpoint, data) {
         data.context = dataBreakpoint;
         data.name.textContent = dataBreakpoint.description;
-        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), dataBreakpoint, this.labelService, this.debugService.getModel());
+        const {
+            icon,
+            message
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            dataBreakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.icon, message ? message : "")
+        );
         data.checkbox.checked = dataBreakpoint.enabled;
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.breakpoint, message ? message : "")
+        );
         if (dataBreakpoint.modeLabel) {
             data.badge.textContent = dataBreakpoint.modeLabel;
-            data.badge.style.display = 'block';
-        }
-        else {
-            data.badge.style.display = 'none';
+            data.badge.style.display = "block";
+        } else {
+            data.badge.style.display = "none";
         }
         const session = this.debugService.getViewModel().focusedSession;
-        data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsDataBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
+        data.breakpoint.classList.toggle(
+            "disabled",
+            (session && !session.capabilities.supportsDataBreakpoints) || !this.debugService.getModel().areBreakpointsActivated()
+        );
         if (session && !session.capabilities.supportsDataBreakpoints) {
-            data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localize(6504, "Data breakpoints are not supported by this debug type"))));
+            data.elementDisposables.add(
+                this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.breakpoint, ( localize(6814, "Data breakpoints are not supported by this debug type")))
+            );
         }
         if (dataBreakpoint.accessType) {
-            const accessType = dataBreakpoint.accessType === 'read' ? ( localize(6505, "Read")) : dataBreakpoint.accessType === 'write' ? ( localize(6506, "Write")) : ( localize(6507, "Access"));
+            const accessType = dataBreakpoint.accessType === "read" ? ( localize(6815, "Read")) : dataBreakpoint.accessType === "write" ? ( localize(6816, "Write")) : ( localize(6817, "Access"));
             data.accessType.textContent = accessType;
-        }
-        else {
-            data.accessType.textContent = '';
+        } else {
+            data.accessType.textContent = "";
         }
         if (dataBreakpoint.condition && dataBreakpoint.hitCondition) {
             data.condition.textContent = ( localize(
-                6502,
+                6812,
                 "Condition: {0} | Hit Count: {1}",
                 dataBreakpoint.condition,
                 dataBreakpoint.hitCondition
             ));
-        }
-        else {
-            data.condition.textContent = dataBreakpoint.condition || dataBreakpoint.hitCondition || '';
+        } else {
+            data.condition.textContent = dataBreakpoint.condition || dataBreakpoint.hitCondition || "";
         }
         this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
-        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes('data').length > 1);
-        this.breakpointItemType.set('dataBreakpoint');
+        this.breakpointHasMultipleModes.set(this.debugService.getModel().getBreakpointModes("data").length > 1);
+        this.breakpointItemType.set("dataBreakpoint");
         this.breakpointIsDataBytes.set(dataBreakpoint.src.type === DataBreakpointSetType.Address);
-        const { primary } = getActionBarActions(this.menu.getActions({ arg: dataBreakpoint, shouldForwardArgs: true }), 'inline');
+        const {
+            primary
+        } = getActionBarActions(this.menu.getActions({
+            arg: dataBreakpoint,
+            shouldForwardArgs: true
+        }), "inline");
         data.actionBar.clear();
-        data.actionBar.push(primary, { icon: true, label: false });
+        data.actionBar.push(primary, {
+            icon: true,
+            label: false
+        });
         breakpointIdToActionBarDomeNode.set(dataBreakpoint.getId(), data.actionBar.domNode);
         this.breakpointIsDataBytes.reset();
     }
@@ -1024,19 +1236,19 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         templateData.templateDisposables.dispose();
     }
 };
-DataBreakpointsRenderer = DataBreakpointsRenderer_1 = ( __decorate([
-    ( __param(5, IDebugService)),
-    ( __param(6, IHoverService)),
-    ( __param(7, ILabelService))
-], DataBreakpointsRenderer));
+DataBreakpointsRenderer = DataBreakpointsRenderer_1 = ( __decorate([( __param(5, IDebugService)), ( __param(6, IHoverService)), ( __param(7, ILabelService))], DataBreakpointsRenderer));
 let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
-    static { InstructionBreakpointsRenderer_1 = this; }
+    static {
+        InstructionBreakpointsRenderer_1 = this;
+    }
     constructor(debugService, hoverService, labelService) {
         this.debugService = debugService;
         this.hoverService = hoverService;
         this.labelService = labelService;
     }
-    static { this.ID = 'instructionBreakpoints'; }
+    static {
+        this.ID = "instructionBreakpoints";
+    }
     get templateId() {
         return InstructionBreakpointsRenderer_1.ID;
     }
@@ -1045,20 +1257,20 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
         data.elementDisposables = ( new DisposableStore());
         data.templateDisposables = ( new DisposableStore());
         data.templateDisposables.add(data.elementDisposables);
-        data.breakpoint = append(container, $('.breakpoint'));
-        data.icon = $('.icon');
+        data.breakpoint = append(container, $(".breakpoint"));
+        data.icon = $(".icon");
         data.checkbox = createCheckbox(data.templateDisposables);
-        data.templateDisposables.add(addStandardDisposableListener(data.checkbox, 'change', (e) => {
+        data.templateDisposables.add(data.checkbox.onChange(() => {
             this.debugService.enableOrDisableBreakpoints(!data.context.enabled, data.context);
         }));
         append(data.breakpoint, data.icon);
-        append(data.breakpoint, data.checkbox);
-        data.name = append(data.breakpoint, $('span.name'));
-        data.address = append(data.breakpoint, $('span.file-path'));
+        append(data.breakpoint, data.checkbox.domNode);
+        data.name = append(data.breakpoint, $("span.name"));
+        data.address = append(data.breakpoint, $("span.file-path"));
         data.actionBar = ( new ActionBar(data.breakpoint));
         data.templateDisposables.add(data.actionBar);
-        const badgeContainer = append(data.breakpoint, $('.badge-container'));
-        data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
+        const badgeContainer = append(data.breakpoint, $(".badge-container"));
+        data.badge = append(badgeContainer, $("span.line-number.monaco-count-badge"));
         return data;
     }
     renderElement(node, index, data) {
@@ -1069,23 +1281,37 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
     }
     renderInstructionBreakpoint(breakpoint, data) {
         data.context = breakpoint;
-        data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
-        data.name.textContent = '0x' + ( breakpoint.address.toString(16));
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.name, ( localize(6508, "Decimal Address: {0}", (breakpoint.address.toString())))));
+        data.breakpoint.classList.toggle("disabled", !this.debugService.getModel().areBreakpointsActivated());
+        data.name.textContent = "0x" + ( breakpoint.address.toString(16));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.name, ( localize(6818, "Decimal Address: {0}", (breakpoint.address.toString()))))
+        );
         data.checkbox.checked = breakpoint.enabled;
-        const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService, this.debugService.getModel());
+        const {
+            message,
+            icon
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            breakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
+        data.elementDisposables.add(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("mouse"),
+            data.breakpoint,
+            breakpoint.message || message || ""
+        ));
         const debugActive = this.debugService.state === State.Running || this.debugService.state === State.Stopped;
         if (debugActive && !breakpoint.verified) {
-            data.breakpoint.classList.add('disabled');
+            data.breakpoint.classList.add("disabled");
         }
         if (breakpoint.modeLabel) {
             data.badge.textContent = breakpoint.modeLabel;
-            data.badge.style.display = 'block';
-        }
-        else {
-            data.badge.style.display = 'none';
+            data.badge.style.display = "block";
+        } else {
+            data.badge.style.display = "none";
         }
     }
     disposeElement(node, index, templateData) {
@@ -1098,11 +1324,7 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
         templateData.templateDisposables.dispose();
     }
 };
-InstructionBreakpointsRenderer = InstructionBreakpointsRenderer_1 = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IHoverService)),
-    ( __param(2, ILabelService))
-], InstructionBreakpointsRenderer));
+InstructionBreakpointsRenderer = InstructionBreakpointsRenderer_1 = ( __decorate([( __param(0, IDebugService)), ( __param(1, IHoverService)), ( __param(2, ILabelService))], InstructionBreakpointsRenderer));
 class FunctionBreakpointInputRenderer {
     constructor(view, debugService, contextViewService, hoverService, labelService) {
         this.view = view;
@@ -1111,56 +1333,59 @@ class FunctionBreakpointInputRenderer {
         this.hoverService = hoverService;
         this.labelService = labelService;
     }
-    static { this.ID = 'functionbreakpointinput'; }
+    static {
+        this.ID = "functionbreakpointinput";
+    }
     get templateId() {
         return FunctionBreakpointInputRenderer.ID;
     }
     renderTemplate(container) {
         const template = Object.create(null);
         const toDispose = ( new DisposableStore());
-        const breakpoint = append(container, $('.breakpoint'));
-        template.icon = $('.icon');
+        const breakpoint = append(container, $(".breakpoint"));
+        template.icon = $(".icon");
         template.checkbox = createCheckbox(toDispose);
         append(breakpoint, template.icon);
-        append(breakpoint, template.checkbox);
+        append(breakpoint, template.checkbox.domNode);
         this.view.breakpointInputFocused.set(true);
-        const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
-        const inputBox = ( new InputBox(
-            inputBoxContainer,
-            this.contextViewService,
-            { inputBoxStyles: defaultInputBoxStyles }
-        ));
+        const inputBoxContainer = append(breakpoint, $(".inputBoxContainer"));
+        const inputBox = ( new InputBox(inputBoxContainer, this.contextViewService, {
+            inputBoxStyles: defaultInputBoxStyles
+        }));
         toDispose.add(inputBox);
-        const wrapUp = (success) => {
+        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 === "name") {
+                        this.debugService.updateFunctionBreakpoint(id, {
+                            name: inputBox.value
+                        });
                     }
-                    if (template.type === 'condition') {
-                        this.debugService.updateFunctionBreakpoint(id, { condition: inputBox.value });
+                    if (template.type === "condition") {
+                        this.debugService.updateFunctionBreakpoint(id, {
+                            condition: inputBox.value
+                        });
                     }
-                    if (template.type === 'hitCount') {
-                        this.debugService.updateFunctionBreakpoint(id, { hitCondition: inputBox.value });
+                    if (template.type === "hitCount") {
+                        this.debugService.updateFunctionBreakpoint(id, {
+                            hitCondition: inputBox.value
+                        });
                     }
-                }
-                else {
-                    if (template.type === 'name' && !template.breakpoint.name) {
+                } else {
+                    if (template.type === "name" && !template.breakpoint.name) {
                         this.debugService.removeFunctionBreakpoints(id);
-                    }
-                    else {
+                    } else {
                         this.view.renderInputBox(undefined);
                     }
                 }
-            }
-            finally {
+            } finally {
                 template.updating = false;
             }
         };
-        toDispose.add(addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+        toDispose.add(addStandardDisposableListener(inputBox.inputElement, "keydown", e => {
             const isEscape = e.equals(KeyCode.Escape);
             const isEnter = e.equals(KeyCode.Enter);
             if (isEscape || isEnter) {
@@ -1169,7 +1394,7 @@ class FunctionBreakpointInputRenderer {
                 wrapUp(isEnter);
             }
         }));
-        toDispose.add(addDisposableListener(inputBox.inputElement, 'blur', () => {
+        toDispose.add(addDisposableListener(inputBox.inputElement, "blur", () => {
             if (!template.updating) {
                 wrapUp(!!inputBox.value);
             }
@@ -1183,28 +1408,38 @@ class FunctionBreakpointInputRenderer {
     renderElement(node, _index, data) {
         const functionBreakpoint = node.element;
         data.breakpoint = functionBreakpoint;
-        data.type = this.view.inputBoxData?.type || 'name';
-        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), functionBreakpoint, this.labelService, this.debugService.getModel());
+        data.type = this.view.inputBoxData?.type || "name";
+        const {
+            icon,
+            message
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            functionBreakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.icon, message ? message : "")
+        );
         data.checkbox.checked = functionBreakpoint.enabled;
-        data.checkbox.disabled = true;
-        data.inputBox.value = functionBreakpoint.name || '';
-        let placeholder = ( localize(6509, "Function to break on"));
-        let ariaLabel = ( localize(6510, "Type function breakpoint."));
-        if (data.type === 'condition') {
-            data.inputBox.value = functionBreakpoint.condition || '';
-            placeholder = ( localize(6511, "Break when expression evaluates to true"));
+        data.checkbox.disable();
+        data.inputBox.value = functionBreakpoint.name || "";
+        let placeholder = ( localize(6819, "Function to break on"));
+        let ariaLabel = ( localize(6820, "Type function breakpoint."));
+        if (data.type === "condition") {
+            data.inputBox.value = functionBreakpoint.condition || "";
+            placeholder = ( localize(6821, "Break when expression evaluates to true"));
             ariaLabel = ( localize(
-                6512,
+                6822,
                 "Type expression. Function breakpoint will break when expression evaluates to true"
             ));
-        }
-        else if (data.type === 'hitCount') {
-            data.inputBox.value = functionBreakpoint.hitCondition || '';
-            placeholder = ( localize(6513, "Break when hit count is met"));
+        } else if (data.type === "hitCount") {
+            data.inputBox.value = functionBreakpoint.hitCondition || "";
+            placeholder = ( localize(6823, "Break when hit count is met"));
             ariaLabel = ( localize(
-                6514,
+                6824,
                 "Type hit count. Function breakpoint will break when hit count is met."
             ));
         }
@@ -1215,8 +1450,7 @@ class FunctionBreakpointInputRenderer {
             data.inputBox.select();
         }, 0);
     }
-    renderCompressedElements(node, _index, data) {
-    }
+    renderCompressedElements(node, _index, data) {}
     disposeElement(node, index, templateData) {
         templateData.elementDisposables.clear();
     }
@@ -1235,48 +1469,50 @@ class DataBreakpointInputRenderer {
         this.hoverService = hoverService;
         this.labelService = labelService;
     }
-    static { this.ID = 'databreakpointinput'; }
+    static {
+        this.ID = "databreakpointinput";
+    }
     get templateId() {
         return DataBreakpointInputRenderer.ID;
     }
     renderTemplate(container) {
         const template = Object.create(null);
         const toDispose = ( new DisposableStore());
-        const breakpoint = append(container, $('.breakpoint'));
-        template.icon = $('.icon');
+        const breakpoint = append(container, $(".breakpoint"));
+        template.icon = $(".icon");
         template.checkbox = createCheckbox(toDispose);
         append(breakpoint, template.icon);
-        append(breakpoint, template.checkbox);
+        append(breakpoint, template.checkbox.domNode);
         this.view.breakpointInputFocused.set(true);
-        const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
-        const inputBox = ( new InputBox(
-            inputBoxContainer,
-            this.contextViewService,
-            { inputBoxStyles: defaultInputBoxStyles }
-        ));
+        const inputBoxContainer = append(breakpoint, $(".inputBoxContainer"));
+        const inputBox = ( new InputBox(inputBoxContainer, this.contextViewService, {
+            inputBoxStyles: defaultInputBoxStyles
+        }));
         toDispose.add(inputBox);
-        const wrapUp = (success) => {
+        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 === "condition") {
+                        this.debugService.updateDataBreakpoint(id, {
+                            condition: inputBox.value
+                        });
                     }
-                    if (template.type === 'hitCount') {
-                        this.debugService.updateDataBreakpoint(id, { hitCondition: inputBox.value });
+                    if (template.type === "hitCount") {
+                        this.debugService.updateDataBreakpoint(id, {
+                            hitCondition: inputBox.value
+                        });
                     }
-                }
-                else {
+                } else {
                     this.view.renderInputBox(undefined);
                 }
-            }
-            finally {
+            } finally {
                 template.updating = false;
             }
         };
-        toDispose.add(addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+        toDispose.add(addStandardDisposableListener(inputBox.inputElement, "keydown", e => {
             const isEscape = e.equals(KeyCode.Escape);
             const isEnter = e.equals(KeyCode.Enter);
             if (isEscape || isEnter) {
@@ -1285,7 +1521,7 @@ class DataBreakpointInputRenderer {
                 wrapUp(isEnter);
             }
         }));
-        toDispose.add(addDisposableListener(inputBox.inputElement, 'blur', () => {
+        toDispose.add(addDisposableListener(inputBox.inputElement, "blur", () => {
             if (!template.updating) {
                 wrapUp(!!inputBox.value);
             }
@@ -1299,27 +1535,37 @@ class DataBreakpointInputRenderer {
     renderElement(node, _index, data) {
         const dataBreakpoint = node.element;
         data.breakpoint = dataBreakpoint;
-        data.type = this.view.inputBoxData?.type || 'condition';
-        const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), dataBreakpoint, this.labelService, this.debugService.getModel());
+        data.type = this.view.inputBoxData?.type || "condition";
+        const {
+            icon,
+            message
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            dataBreakpoint,
+            this.labelService,
+            this.debugService.getModel()
+        );
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.elementDisposables.add(this.hoverService.setupManagedHover(getDefaultHoverDelegate('mouse'), data.icon, message ?? ''));
+        data.elementDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), data.icon, 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 = ( localize(6515, "Break when expression evaluates to true"));
+        data.checkbox.disable();
+        data.inputBox.value = "";
+        let placeholder = "";
+        let ariaLabel = "";
+        if (data.type === "condition") {
+            data.inputBox.value = dataBreakpoint.condition || "";
+            placeholder = ( localize(6825, "Break when expression evaluates to true"));
             ariaLabel = ( localize(
-                6516,
+                6826,
                 "Type expression. Data breakpoint will break when expression evaluates to true"
             ));
-        }
-        else if (data.type === 'hitCount') {
-            data.inputBox.value = dataBreakpoint.hitCondition || '';
-            placeholder = ( localize(6517, "Break when hit count is met"));
-            ariaLabel = ( localize(6518, "Type hit count. Data breakpoint will break when hit count is met."));
+        } else if (data.type === "hitCount") {
+            data.inputBox.value = dataBreakpoint.hitCondition || "";
+            placeholder = ( localize(6827, "Break when hit count is met"));
+            ariaLabel = ( localize(6828, "Type hit count. Data breakpoint will break when hit count is met."));
         }
         data.inputBox.setAriaLabel(ariaLabel);
         data.inputBox.setPlaceHolder(placeholder);
@@ -1328,8 +1574,7 @@ class DataBreakpointInputRenderer {
             data.inputBox.select();
         }, 0);
     }
-    renderCompressedElements(node, _index, data) {
-    }
+    renderCompressedElements(node, _index, data) {}
     disposeElement(node, index, templateData) {
         templateData.elementDisposables.clear();
     }
@@ -1346,35 +1591,37 @@ class ExceptionBreakpointInputRenderer {
         this.debugService = debugService;
         this.contextViewService = contextViewService;
     }
-    static { this.ID = 'exceptionbreakpointinput'; }
+    static {
+        this.ID = "exceptionbreakpointinput";
+    }
     get templateId() {
         return ExceptionBreakpointInputRenderer.ID;
     }
     renderTemplate(container) {
         const toDispose = ( new DisposableStore());
-        const breakpoint = append(container, $('.breakpoint'));
-        breakpoint.classList.add('exception');
+        const breakpoint = append(container, $(".breakpoint"));
+        breakpoint.classList.add("exception");
         const checkbox = createCheckbox(toDispose);
-        append(breakpoint, checkbox);
+        append(breakpoint, checkbox.domNode);
         this.view.breakpointInputFocused.set(true);
-        const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
+        const inputBoxContainer = append(breakpoint, $(".inputBoxContainer"));
         const inputBox = ( new InputBox(inputBoxContainer, this.contextViewService, {
-            ariaLabel: ( localize(6519, "Type exception breakpoint condition")),
+            ariaLabel: ( localize(6829, "Type exception breakpoint condition")),
             inputBoxStyles: defaultInputBoxStyles
         }));
         toDispose.add(inputBox);
-        const wrapUp = (success) => {
+        const wrapUp = success => {
             if (!templateData.currentBreakpoint) {
                 return;
             }
             this.view.breakpointInputFocused.set(false);
             let newCondition = templateData.currentBreakpoint.condition;
             if (success) {
-                newCondition = inputBox.value !== '' ? inputBox.value : undefined;
+                newCondition = inputBox.value !== "" ? inputBox.value : undefined;
             }
             this.debugService.setExceptionBreakpointCondition(templateData.currentBreakpoint, newCondition);
         };
-        toDispose.add(addStandardDisposableListener(inputBox.inputElement, 'keydown', (e) => {
+        toDispose.add(addStandardDisposableListener(inputBox.inputElement, "keydown", e => {
             const isEscape = e.equals(KeyCode.Escape);
             const isEnter = e.equals(KeyCode.Enter);
             if (isEscape || isEnter) {
@@ -1383,7 +1630,7 @@ class ExceptionBreakpointInputRenderer {
                 wrapUp(isEnter);
             }
         }));
-        toDispose.add(addDisposableListener(inputBox.inputElement, 'blur', () => {
+        toDispose.add(addDisposableListener(inputBox.inputElement, "blur", () => {
             setTimeout(() => {
                 wrapUp(true);
             });
@@ -1394,25 +1641,24 @@ class ExceptionBreakpointInputRenderer {
             inputBox,
             checkbox,
             templateDisposables: toDispose,
-            elementDisposables: ( new DisposableStore()),
+            elementDisposables: ( new DisposableStore())
         };
         return templateData;
     }
     renderElement(node, _index, data) {
         const exceptionBreakpoint = node.element;
-        const placeHolder = exceptionBreakpoint.conditionDescription || ( localize(6520, "Break when expression evaluates to true"));
+        const placeHolder = exceptionBreakpoint.conditionDescription || ( localize(6830, "Break when expression evaluates to true"));
         data.inputBox.setPlaceHolder(placeHolder);
         data.currentBreakpoint = exceptionBreakpoint;
         data.checkbox.checked = exceptionBreakpoint.enabled;
-        data.checkbox.disabled = true;
-        data.inputBox.value = exceptionBreakpoint.condition || '';
+        data.checkbox.disable();
+        data.inputBox.value = exceptionBreakpoint.condition || "";
         setTimeout(() => {
             data.inputBox.focus();
             data.inputBox.select();
         }, 0);
     }
-    renderCompressedElements(node, _index, data) {
-    }
+    renderCompressedElements(node, _index, data) {}
     disposeElement(node, index, templateData) {
         templateData.elementDisposables.clear();
     }
@@ -1429,10 +1675,10 @@ class BreakpointsAccessibilityProvider {
         this.labelService = labelService;
     }
     getWidgetAriaLabel() {
-        return localize(6521, "Breakpoints");
+        return localize(6831, "Breakpoints");
     }
     getRole() {
-        return 'checkbox';
+        return "checkbox";
     }
     isChecked(element) {
         if (element instanceof BreakpointsFolderItem) {
@@ -1443,7 +1689,7 @@ class BreakpointsAccessibilityProvider {
     getAriaLabel(element) {
         if (element instanceof BreakpointsFolderItem) {
             return localize(
-                6522,
+                6832,
                 "Breakpoints in {0}, {1} breakpoints",
                 basenameOrAuthority(element.uri),
                 element.breakpoints.length
@@ -1452,7 +1698,15 @@ class BreakpointsAccessibilityProvider {
         if (element instanceof ExceptionBreakpoint) {
             return ( element.toString());
         }
-        const { message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), element, this.labelService, this.debugService.getModel());
+        const {
+            message
+        } = getBreakpointMessageAndIcon(
+            this.debugService.state,
+            this.debugService.getModel().areBreakpointsActivated(),
+            element,
+            this.labelService,
+            this.debugService.getModel()
+        );
         const toString = ( element.toString());
         return message ? `${toString}, ${message}` : toString;
     }
@@ -1489,11 +1743,11 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
     if (!breakpoint$1.enabled || !breakpointsActivated) {
         return {
             icon: breakpointIcon.disabled,
-            message: breakpoint$1.logMessage ? ( localize(6523, "Disabled Logpoint")) : ( localize(6524, "Disabled Breakpoint")),
+            message: breakpoint$1.logMessage ? ( localize(6833, "Disabled Logpoint")) : ( localize(6834, "Disabled Breakpoint"))
         };
     }
-    const appendMessage = (text) => {
-        return breakpoint$1.message ? text.concat(', ' + breakpoint$1.message) : text;
+    const appendMessage = text => {
+        return breakpoint$1.message ? text.concat(", " + breakpoint$1.message) : text;
     };
     if (debugActive && breakpoint$1 instanceof Breakpoint && breakpoint$1.pending) {
         return {
@@ -1503,7 +1757,7 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
     if (debugActive && !breakpoint$1.verified) {
         return {
             icon: breakpointIcon.unverified,
-            message: breakpoint$1.message ? breakpoint$1.message : (breakpoint$1.logMessage ? ( localize(6525, "Unverified Logpoint")) : ( localize(6526, "Unverified Breakpoint"))),
+            message: breakpoint$1.message ? breakpoint$1.message : (breakpoint$1.logMessage ? ( localize(6835, "Unverified Logpoint")) : ( localize(6836, "Unverified Breakpoint"))),
             showAdapterUnverifiedMessage: true
         };
     }
@@ -1511,61 +1765,59 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localize(6527, "Data breakpoints not supported by this debug type")),
+                message: ( localize(6837, "Data breakpoints not supported by this debug type"))
             };
         }
         return {
             icon: breakpointIcon.regular,
-            message: breakpoint$1.message || ( localize(6528, "Data Breakpoint"))
+            message: breakpoint$1.message || ( localize(6838, "Data Breakpoint"))
         };
     }
     if (breakpoint$1 instanceof FunctionBreakpoint) {
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localize(6529, "Function breakpoints not supported by this debug type")),
+                message: ( localize(6839, "Function breakpoints not supported by this debug type"))
             };
         }
         const messages = [];
-        messages.push(breakpoint$1.message || ( localize(6530, "Function Breakpoint")));
+        messages.push(breakpoint$1.message || ( localize(6840, "Function Breakpoint")));
         if (breakpoint$1.condition) {
-            messages.push(( localize(6531, "Condition: {0}", breakpoint$1.condition)));
+            messages.push(( localize(6841, "Condition: {0}", breakpoint$1.condition)));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localize(6532, "Hit Count: {0}", breakpoint$1.hitCondition)));
+            messages.push(( localize(6842, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         return {
             icon: breakpointIcon.regular,
-            message: appendMessage(messages.join('\n'))
+            message: appendMessage(messages.join("\n"))
         };
     }
     if (breakpoint$1 instanceof InstructionBreakpoint) {
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localize(6533, "Instruction breakpoints not supported by this debug type")),
+                message: ( localize(6843, "Instruction breakpoints not supported by this debug type"))
             };
         }
         const messages = [];
         if (breakpoint$1.message) {
             messages.push(breakpoint$1.message);
-        }
-        else if (breakpoint$1.instructionReference) {
+        } else if (breakpoint$1.instructionReference) {
             messages.push(( localize(
-                6534,
+                6844,
                 "Instruction breakpoint at address {0}",
                 breakpoint$1.instructionReference
             )));
-        }
-        else {
-            messages.push(( localize(6535, "Instruction breakpoint")));
+        } else {
+            messages.push(( localize(6845, "Instruction breakpoint")));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localize(6532, "Hit Count: {0}", breakpoint$1.hitCondition)));
+            messages.push(( localize(6842, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         return {
             icon: breakpointIcon.regular,
-            message: appendMessage(messages.join('\n'))
+            message: appendMessage(messages.join("\n"))
         };
     }
     let triggeringBreakpoint;
@@ -1577,30 +1829,32 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         let icon = breakpoint$1.logMessage ? logBreakpoint.regular : conditionalBreakpoint.regular;
         if (!breakpoint$1.supported) {
             icon = debugBreakpointUnsupported;
-            messages.push(( localize(6536, "Breakpoints of this type are not supported by the debugger")));
+            messages.push(( localize(6846, "Breakpoints of this type are not supported by the debugger")));
         }
         if (breakpoint$1.logMessage) {
-            messages.push(( localize(6537, "Log Message: {0}", breakpoint$1.logMessage)));
+            messages.push(( localize(6847, "Log Message: {0}", breakpoint$1.logMessage)));
         }
         if (breakpoint$1.condition) {
-            messages.push(( localize(6531, "Condition: {0}", breakpoint$1.condition)));
+            messages.push(( localize(6841, "Condition: {0}", breakpoint$1.condition)));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localize(6532, "Hit Count: {0}", breakpoint$1.hitCondition)));
+            messages.push(( localize(6842, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         if (triggeringBreakpoint) {
             messages.push(( localize(
-                6538,
+                6848,
                 "Hit after breakpoint: {0}",
-                `${labelService.getUriLabel(triggeringBreakpoint.uri, { relative: true })}: ${triggeringBreakpoint.lineNumber}`
+                `${labelService.getUriLabel(triggeringBreakpoint.uri, {
+    relative: true
+})}: ${triggeringBreakpoint.lineNumber}`
             )));
         }
         return {
             icon,
-            message: appendMessage(messages.join('\n'))
+            message: appendMessage(messages.join("\n"))
         };
     }
-    const message = breakpoint$1.message ? breakpoint$1.message : breakpoint$1 instanceof Breakpoint && labelService ? labelService.getUriLabel(breakpoint$1.uri) : ( localize(6539, "Breakpoint"));
+    const message = breakpoint$1.message ? breakpoint$1.message : breakpoint$1 instanceof Breakpoint && labelService ? labelService.getUriLabel(breakpoint$1.uri) : ( localize(6849, "Breakpoint"));
     return {
         icon: breakpointIcon.regular,
         message
@@ -1609,24 +1863,24 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.addFunctionBreakpointAction',
+            id: "workbench.debug.viewlet.action.addFunctionBreakpointAction",
             title: {
-                ...( localize2(6540, "Add Function Breakpoint")),
-                mnemonicTitle: ( localize(6541, "&&Function Breakpoint...")),
+                ...( localize2(6850, "Add Function Breakpoint")),
+                mnemonicTitle: ( localize(6851, "&&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
-                }]
+                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
+            }]
         });
     }
     async run(accessor) {
@@ -1656,10 +1910,9 @@ class MemoryBreakpointAction extends Action2 {
         let info;
         try {
             info = await session.dataBytesBreakpointInfo(range.address, range.bytes);
-        }
-        catch (e) {
+        } catch (e) {
             notifications.error(( localize(
-                6542,
+                6852,
                 "Failed to set data breakpoint at {0}: {1}",
                 range.address,
                 e.message
@@ -1668,16 +1921,23 @@ class MemoryBreakpointAction extends Action2 {
         if (!info?.dataId) {
             return;
         }
-        let accessType = 'write';
+        let accessType = "write";
         if (info.accessTypes && info.accessTypes?.length > 1) {
-            const accessTypes = ( info.accessTypes.map(type => ({ label: type })));
-            const selectedAccessType = await quickInput.pick(accessTypes, { placeHolder: ( localize(6543, "Select the access type to monitor")) });
+            const accessTypes = ( info.accessTypes.map(type => ({
+                label: type
+            })));
+            const selectedAccessType = await quickInput.pick(accessTypes, {
+                placeHolder: ( localize(6853, "Select the access type to monitor"))
+            });
             if (!selectedAccessType) {
                 return;
             }
             accessType = selectedAccessType.label;
         }
-        const src = { type: DataBreakpointSetType.Address, ...range };
+        const src = {
+            type: DataBreakpointSetType.Address,
+            ...range
+        };
         if (existingBreakpoint) {
             await debugService.removeDataBreakpoints(existingBreakpoint.getId());
         }
@@ -1687,17 +1947,20 @@ class MemoryBreakpointAction extends Action2 {
             canPersist: true,
             accessTypes: info.accessTypes,
             accessType: accessType,
-            initialSessionData: { session, dataId: info.dataId }
+            initialSessionData: {
+                session,
+                dataId: info.dataId
+            }
         });
     }
     getRange(quickInput, defaultValue) {
         return (new Promise(resolve => {
             const disposables = ( new DisposableStore());
             const input = disposables.add(quickInput.createInputBox());
-            input.prompt = ( localize(6544, "Enter a memory range in which to break"));
+            input.prompt = ( localize(6854, "Enter a memory range in which to break"));
             input.placeholder = ( localize(
-                6545,
-                'Absolute range (0x1234 - 0x1300) or range of bytes after an address (0x1234 + 0xff)'
+                6855,
+                "Absolute range (0x1234 - 0x1300) or range of bytes after an address (0x1234 + 0xff)"
             ));
             if (defaultValue) {
                 input.value = defaultValue;
@@ -1709,10 +1972,11 @@ class MemoryBreakpointAction extends Action2 {
             }));
             disposables.add(input.onDidAccept(() => {
                 const r = this.parseAddress(input.value, true);
-                if (hasKey(r, { error: true })) {
+                if (hasKey(r, {
+                    error: true
+                })) {
                     input.validationMessage = r.error;
-                }
-                else {
+                } else {
                     resolve(r);
                 }
                 input.dispose();
@@ -1728,20 +1992,24 @@ class MemoryBreakpointAction extends Action2 {
     parseAddress(range, isFinal) {
         const parts = /^(\S+)\s*(?:([+-])\s*(\S+))?/.exec(range);
         if (!parts) {
-            return { error: ( localize(
-                6546,
-                'Address should be a range of numbers the form "[Start] - [End]" or "[Start] + [Bytes]"'
-            )) };
+            return {
+                error: ( localize(
+                    6856,
+                    "Address should be a range of numbers the form \"[Start] - [End]\" or \"[Start] + [Bytes]\""
+                ))
+            };
         }
-        const isNum = (e) => isFinal ? /^0x[0-9a-f]*|[0-9]*$/i.test(e) : /^0x[0-9a-f]+|[0-9]+$/i.test(e);
-        const [, startStr, sign = '+', endStr = '1'] = parts;
+        const isNum = e => isFinal ? /^0x[0-9a-f]*|[0-9]*$/i.test(e) : /^0x[0-9a-f]+|[0-9]+$/i.test(e);
+        const [, startStr, sign = "+", endStr = "1"] = parts;
         for (const n of [startStr, endStr]) {
             if (!isNum(n)) {
-                return { error: ( localize(
-                    6547,
-                    'Number must be a decimal integer or hex value starting with \"0x\", got {0}',
-                    n
-                )) };
+                return {
+                    error: ( localize(
+                        6857,
+                        "Number must be a decimal integer or hex value starting with \"0x\", got {0}",
+                        n
+                    ))
+                };
             }
         }
         if (!isFinal) {
@@ -1750,68 +2018,76 @@ class MemoryBreakpointAction extends Action2 {
         const start = BigInt(startStr);
         const end = BigInt(endStr);
         const address = `0x${( start.toString(16))}`;
-        if (sign === '-') {
+        if (sign === "-") {
             if (start > end) {
-                return { error: ( localize(6548, 'End ({1}) should be greater than Start ({0})', startStr, endStr)) };
+                return {
+                    error: ( localize(6858, "End ({1}) should be greater than Start ({0})", startStr, endStr))
+                };
             }
-            return { address, bytes: Number(end - start) };
+            return {
+                address,
+                bytes: Number(end - start)
+            };
         }
-        return { address, bytes: Number(end) };
+        return {
+            address,
+            bytes: Number(end)
+        };
     }
 }
 registerAction2(class extends MemoryBreakpointAction {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.addDataBreakpointOnAddress',
+            id: "workbench.debug.viewlet.action.addDataBreakpointOnAddress",
             title: {
-                ...( localize2(6549, "Add Data Breakpoint at Address")),
-                mnemonicTitle: ( localize(6550, "&&Data Breakpoint...")),
+                ...( localize2(6859, "Add Data Breakpoint at Address")),
+                mnemonicTitle: ( localize(6860, "&&Data Breakpoint..."))
             },
             f1: true,
             icon: watchExpressionsAddDataBreakpoint,
             menu: [{
-                    id: MenuId.ViewTitle,
-                    group: 'navigation',
-                    order: 11,
-                    when: ( ContextKeyExpr.and(CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED, ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))))
-                }, {
-                    id: MenuId.MenubarNewBreakpointMenu,
-                    group: '1_breakpoints',
-                    order: 4,
-                    when: CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED
-                }]
+                id: MenuId.ViewTitle,
+                group: "navigation",
+                order: 11,
+                when: ( ContextKeyExpr.and(CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED, ( ContextKeyExpr.equals("view", BREAKPOINTS_VIEW_ID))))
+            }, {
+                id: MenuId.MenubarNewBreakpointMenu,
+                group: "1_breakpoints",
+                order: 4,
+                when: CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED
+            }]
         });
     }
 });
 registerAction2(class extends MemoryBreakpointAction {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.editDataBreakpointOnAddress',
-            title: ( localize2(6551, "Edit Address...")),
+            id: "workbench.debug.viewlet.action.editDataBreakpointOnAddress",
+            title: ( localize2(6861, "Edit Address...")),
             menu: [{
-                    id: MenuId.DebugBreakpointsContext,
-                    when: ( ContextKeyExpr.and(
-                        CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED,
-                        CONTEXT_BREAKPOINT_ITEM_IS_DATA_BYTES
-                    )),
-                    group: 'navigation',
-                    order: 15,
-                }]
+                id: MenuId.DebugBreakpointsContext,
+                when: ( ContextKeyExpr.and(
+                    CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED,
+                    CONTEXT_BREAKPOINT_ITEM_IS_DATA_BYTES
+                )),
+                group: "navigation",
+                order: 15
+            }]
         });
     }
 });
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.toggleBreakpointsActivatedAction',
-            title: ( localize2(6552, 'Toggle Activate Breakpoints')),
+            id: "workbench.debug.viewlet.action.toggleBreakpointsActivatedAction",
+            title: ( localize2(6862, "Toggle Activate Breakpoints")),
             f1: true,
             icon: breakpointsActivate,
             menu: {
                 id: MenuId.ViewTitle,
-                group: 'navigation',
+                group: "navigation",
                 order: 20,
-                when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                when: ( ContextKeyExpr.equals("view", BREAKPOINTS_VIEW_ID))
             }
         });
     }
@@ -1823,34 +2099,31 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.removeBreakpoint',
-            title: ( localize(6553, "Remove Breakpoint")),
+            id: "workbench.debug.viewlet.action.removeBreakpoint",
+            title: ( localize(6863, "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'))
-                }]
+                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) {
+        } else if (breakpoint instanceof FunctionBreakpoint) {
             await debugService.removeFunctionBreakpoints(breakpoint.getId());
-        }
-        else if (breakpoint instanceof DataBreakpoint) {
+        } else if (breakpoint instanceof DataBreakpoint) {
             await debugService.removeDataBreakpoints(breakpoint.getId());
-        }
-        else if (breakpoint instanceof InstructionBreakpoint) {
+        } else if (breakpoint instanceof InstructionBreakpoint) {
             await debugService.removeInstructionBreakpoints(breakpoint.instructionReference, breakpoint.offset);
         }
     }
@@ -1858,29 +2131,29 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.removeAllBreakpoints',
+            id: "workbench.debug.viewlet.action.removeAllBreakpoints",
             title: {
-                ...( localize2(6554, "Remove All Breakpoints")),
-                mnemonicTitle: ( localize(6555, "Remove &&All Breakpoints")),
+                ...( localize2(6864, "Remove All Breakpoints")),
+                mnemonicTitle: ( localize(6865, "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
-                }]
+                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) {
@@ -1894,24 +2167,24 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.enableAllBreakpoints',
+            id: "workbench.debug.viewlet.action.enableAllBreakpoints",
             title: {
-                ...( localize2(6556, "Enable All Breakpoints")),
-                mnemonicTitle: ( localize(6557, "&&Enable All Breakpoints")),
+                ...( localize2(6866, "Enable All Breakpoints")),
+                mnemonicTitle: ( localize(6867, "&&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
-                }]
+                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) {
@@ -1922,24 +2195,24 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.disableAllBreakpoints',
+            id: "workbench.debug.viewlet.action.disableAllBreakpoints",
             title: {
-                ...( localize2(6558, "Disable All Breakpoints")),
-                mnemonicTitle: ( localize(6559, "Disable A&&ll Breakpoints")),
+                ...( localize2(6868, "Disable All Breakpoints")),
+                mnemonicTitle: ( localize(6869, "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
-                }]
+                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) {
@@ -1950,16 +2223,16 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.reapplyBreakpointsAction',
-            title: ( localize2(6560, 'Reapply All Breakpoints')),
+            id: "workbench.debug.viewlet.action.reapplyBreakpointsAction",
+            title: ( localize2(6870, "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'))))
-                }]
+                id: MenuId.DebugBreakpointsContext,
+                group: "z_commands",
+                order: 30,
+                when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo("exceptionBreakpoint"))))
+            }]
         });
     }
     async run(accessor) {
@@ -1970,43 +2243,43 @@ registerAction2(class extends Action2 {
 registerAction2(class extends Action2 {
     constructor() {
         super({
-            id: 'workbench.debug.viewlet.action.toggleBreakpointsPresentation',
-            title: ( localize2(6561, "Toggle Breakpoints View Presentation")),
+            id: "workbench.debug.viewlet.action.toggleBreakpointsPresentation",
+            title: ( localize2(6871, "Toggle Breakpoints View Presentation")),
             f1: true,
             icon: breakpointsViewIcon,
             menu: {
                 id: MenuId.ViewTitle,
-                group: 'navigation',
+                group: "navigation",
                 order: 10,
-                when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                when: ( ContextKeyExpr.equals("view", BREAKPOINTS_VIEW_ID))
             }
         });
     }
     async run(accessor) {
         const configurationService = accessor.get(IConfigurationService);
-        const currentPresentation = configurationService.getValue('debug.breakpointsView.presentation');
-        const newPresentation = currentPresentation === 'tree' ? 'list' : 'tree';
-        await configurationService.updateValue('debug.breakpointsView.presentation', newPresentation);
+        const currentPresentation = configurationService.getValue("debug.breakpointsView.presentation");
+        const newPresentation = currentPresentation === "tree" ? "list" : "tree";
+        await configurationService.updateValue("debug.breakpointsView.presentation", newPresentation);
     }
 });
 registerAction2(class extends ViewAction {
     constructor() {
         super({
-            id: 'debug.editBreakpoint',
+            id: "debug.editBreakpoint",
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localize(6562, "Edit Condition...")),
+            title: ( localize(6872, "Edit Condition...")),
             icon: Codicon.edit,
             precondition: CONTEXT_BREAKPOINT_SUPPORTS_CONDITION,
             menu: [{
-                    id: MenuId.DebugBreakpointsContext,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('functionBreakpoint')),
-                    group: 'navigation',
-                    order: 10
-                }, {
-                    id: MenuId.DebugBreakpointsContext,
-                    group: 'inline',
-                    order: 10
-                }]
+                id: MenuId.DebugBreakpointsContext,
+                when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo("functionBreakpoint")),
+                group: "navigation",
+                order: 10
+            }, {
+                id: MenuId.DebugBreakpointsContext,
+                group: "inline",
+                order: 10
+            }]
         });
     }
     async runInView(accessor, view, breakpoint) {
@@ -2020,11 +2293,15 @@ registerAction2(class extends ViewAction {
                     codeEditor.getContribution(BREAKPOINT_EDITOR_CONTRIBUTION_ID)?.showBreakpointWidget(breakpoint.lineNumber, breakpoint.column);
                 }
             }
-        }
-        else if (breakpoint instanceof FunctionBreakpoint) {
+        } else if (breakpoint instanceof FunctionBreakpoint) {
             const contextMenuService = accessor.get(IContextMenuService);
-            const actions = [( new Action('breakpoint.editCondition', ( localize(6562, "Edit Condition...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'condition' }))),
-                ( new Action('breakpoint.editCondition', ( localize(6563, "Edit Hit Count...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'hitCount' })))];
+            const actions = [( new Action("breakpoint.editCondition", ( localize(6872, "Edit Condition...")), undefined, true, async () => view.renderInputBox({
+                breakpoint,
+                type: "condition"
+            }))), ( new Action("breakpoint.editCondition", ( localize(6873, "Edit Hit Count...")), undefined, true, async () => view.renderInputBox({
+                breakpoint,
+                type: "hitCount"
+            })))];
             const domNode = breakpointIdToActionBarDomeNode.get(breakpoint.getId());
             if (domNode) {
                 contextMenuService.showContextMenu({
@@ -2033,83 +2310,100 @@ registerAction2(class extends ViewAction {
                     onHide: () => dispose(actions)
                 });
             }
-        }
-        else {
-            view.renderInputBox({ breakpoint, type: 'condition' });
+        } else {
+            view.renderInputBox({
+                breakpoint,
+                type: "condition"
+            });
         }
     }
 });
 registerAction2(class extends ViewAction {
     constructor() {
         super({
-            id: 'debug.editFunctionBreakpoint',
+            id: "debug.editFunctionBreakpoint",
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localize(6564, "Edit Function Condition...")),
+            title: ( localize(6874, "Edit Function Condition...")),
             menu: [{
-                    id: MenuId.DebugBreakpointsContext,
-                    group: 'navigation',
-                    order: 10,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint'))
-                }]
+                id: MenuId.DebugBreakpointsContext,
+                group: "navigation",
+                order: 10,
+                when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo("functionBreakpoint"))
+            }]
         });
     }
     runInView(_accessor, view, breakpoint) {
-        view.renderInputBox({ breakpoint, type: 'name' });
+        view.renderInputBox({
+            breakpoint,
+            type: "name"
+        });
     }
 });
 registerAction2(class extends ViewAction {
     constructor() {
         super({
-            id: 'debug.editFunctionBreakpointHitCount',
+            id: "debug.editFunctionBreakpointHitCount",
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localize(6563, "Edit Hit Count...")),
+            title: ( localize(6873, "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'))))
-                }]
+                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' });
+        view.renderInputBox({
+            breakpoint,
+            type: "hitCount"
+        });
     }
 });
 registerAction2(class extends ViewAction {
     constructor() {
         super({
-            id: 'debug.editBreakpointMode',
+            id: "debug.editBreakpointMode",
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localize(6565, "Edit Mode...")),
+            title: ( localize(6875, "Edit Mode...")),
             menu: [{
-                    id: MenuId.DebugBreakpointsContext,
-                    group: 'navigation',
-                    order: 20,
-                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINT_HAS_MODES, ( ContextKeyExpr.or(( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('breakpoint')), ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('exceptionBreakpoint')), ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('instructionBreakpoint'))))))
-                }]
+                id: MenuId.DebugBreakpointsContext,
+                group: "navigation",
+                order: 20,
+                when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINT_HAS_MODES, ( ContextKeyExpr.or(( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo("breakpoint")), ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo("exceptionBreakpoint")), ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo("instructionBreakpoint"))))))
+            }]
         });
     }
     async runInView(accessor, view, breakpoint) {
         const debugService = accessor.get(IDebugService);
         const kind = getModeKindForBreakpoint(breakpoint);
         const modes = debugService.getModel().getBreakpointModes(kind);
-        const picked = await accessor.get(IQuickInputService).pick(( modes.map(
-            mode => ({ label: mode.label, description: mode.description, mode: mode.mode })
-        )), { placeHolder: ( localize(6566, "Select Breakpoint Mode")) });
+        const picked = await accessor.get(IQuickInputService).pick(( modes.map(mode => ({
+            label: mode.label,
+            description: mode.description,
+            mode: mode.mode
+        }))), {
+            placeHolder: ( localize(6876, "Select Breakpoint Mode"))
+        });
         if (!picked) {
             return;
         }
-        if (kind === 'source') {
+        if (kind === "source") {
             const data = ( new Map());
-            data.set(breakpoint.getId(), { mode: picked.mode, modeLabel: picked.label });
+            data.set(breakpoint.getId(), {
+                mode: picked.mode,
+                modeLabel: picked.label
+            });
             debugService.updateBreakpoints(breakpoint.originalUri, data, false);
-        }
-        else if (breakpoint instanceof InstructionBreakpoint) {
+        } else if (breakpoint instanceof InstructionBreakpoint) {
             debugService.removeInstructionBreakpoints(breakpoint.instructionReference, breakpoint.offset);
-            debugService.addInstructionBreakpoint({ ...breakpoint.toJSON(), mode: picked.mode, modeLabel: picked.label });
-        }
-        else if (breakpoint instanceof ExceptionBreakpoint) {
+            debugService.addInstructionBreakpoint({
+                ...breakpoint.toJSON(),
+                mode: picked.mode,
+                modeLabel: picked.label
+            });
+        } else if (breakpoint instanceof ExceptionBreakpoint) {
             breakpoint.mode = picked.mode;
             breakpoint.modeLabel = picked.label;
             debugService.setExceptionBreakpointCondition(breakpoint, breakpoint.condition);