npm - @codingame/monaco-vscode-api - Versions diffs - 4.5.1 → 5.0.0 - Mend

@codingame/monaco-vscode-api 4.5.1 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (886) hide show

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

@@ -4,7 +4,6 @@ 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 { setupCustomHover } from '../../../../base/browser/ui/hover/updatableHoverWidget.js';
 import { InputBox } from '../../../../base/browser/ui/inputbox/inputBox.js';
 import { Action } from '../../../../base/common/actions.js';
 import { equals } from '../../../../base/common/arrays.js';
@@ -45,6 +44,7 @@ import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editor
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
 var BreakpointsRenderer_1, FunctionBreakpointsRenderer_1, DataBreakpointsRenderer_1, InstructionBreakpointsRenderer_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/breakpointsView";
 const $ = $$1;
 function createCheckbox(disposables) {
     const checkbox = $('input');
@@ -60,12 +60,11 @@ function getExpandedBodySize(model, sessionId, countLimit) {
 }
 let BreakpointsView = class BreakpointsView extends ViewPane {
     constructor(options, contextMenuService, debugService, keybindingService, instantiationService, themeService, editorService, contextViewService, configurationService, viewDescriptorService, contextKeyService, openerService, telemetryService, labelService, menuService, hoverService, languageService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.debugService = debugService;
         this.editorService = editorService;
         this.contextViewService = contextViewService;
         this.labelService = labelService;
-        this.hoverService = hoverService;
         this.languageService = languageService;
         this.needsRefresh = false;
         this.needsStateChange = false;
@@ -81,36 +80,47 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
         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)));
+        this.hintDelayer = this._register(( (new RunOnceScheduler(() => this.updateBreakpointsHint(true), 4000))));
     }
     renderBody(container) {
         super.renderBody(container);
         this.element.classList.add('debug-pane');
         container.classList.add('debug-breakpoints');
-        const delegate = ( new BreakpointsDelegate(this));
+        const delegate = ( (new BreakpointsDelegate(this)));
         this.list = this.instantiationService.createInstance(WorkbenchList, 'Breakpoints', container, delegate, [
             this.instantiationService.createInstance(BreakpointsRenderer, this.menu, this.breakpointHasMultipleModes, this.breakpointSupportsCondition, this.breakpointItemType),
-            ( new ExceptionBreakpointsRenderer(
-                this.menu,
-                this.breakpointHasMultipleModes,
-                this.breakpointSupportsCondition,
-                this.breakpointItemType,
-                this.debugService
-            )),
-            ( new ExceptionBreakpointInputRenderer(this, this.debugService, this.contextViewService)),
+            ( (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.labelService)),
+            ( (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.labelService)),
+            ( (new DataBreakpointInputRenderer(
+            this,
+            this.debugService,
+            this.contextViewService,
+            this.hoverService,
+            this.labelService
+        ))),
             this.instantiationService.createInstance(InstructionBreakpointsRenderer),
         ], {
             identityProvider: { getId: (element) => element.getId() },
             multipleSelectionSupport: false,
             keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e },
-            accessibilityProvider: ( new BreakpointsAccessibilityProvider(this.debugService, this.labelService)),
-            overrideStyles: {
-                listBackground: this.getBackgroundColor()
-            }
+            accessibilityProvider: ( (new BreakpointsAccessibilityProvider(this.debugService, this.labelService))),
+            overrideStyles: this.getLocationBasedColors().listOverrideStyles
         });
         CONTEXT_BREAKPOINTS_FOCUSED.bindTo(this.list.contextKeyService);
         this._register(this.list.onContextMenu(this.onListContextMenu, this));
@@ -165,12 +175,12 @@ let BreakpointsView = class BreakpointsView extends ViewPane {
     renderHeaderTitle(container, title) {
         super.renderHeaderTitle(container, title);
         const iconLabelContainer = append(container, $('span.breakpoint-warning'));
-        this.hintContainer = this._register(( new IconLabel(iconLabelContainer, {
+        this.hintContainer = this._register(( (new IconLabel(iconLabelContainer, {
             supportIcons: true, hoverDelegate: {
                 showHover: (options, focus) => this.hoverService.showHover({ content: options.content, target: this.hintContainer.element }, focus),
                 delay: this.configurationService.getValue('workbench.hover.delay')
             }
-        })));
+        }))));
         hide(this.hintContainer.element);
     }
     focus() {
@@ -239,7 +249,7 @@ 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);
+                const mdown = ( (new MarkdownString(undefined, { isTrusted: true }))).appendMarkdown(message);
                 this.hintContainer.setLabel('$(warning)', undefined, { title: { markdown: mdown, markdownNotSupportedFallback: message } });
                 show(this.hintContainer.element);
             }
@@ -310,24 +320,24 @@ 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, ITelemetryService)),
-    ( __param(13, ILabelService)),
-    ( __param(14, IMenuService)),
-    ( __param(15, IHoverService)),
-    ( __param(16, 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, ITelemetryService))),
+    ( (__param(13, ILabelService))),
+    ( (__param(14, IMenuService))),
+    ( (__param(15, IHoverService))),
+    ( (__param(16, ILanguageService)))
+], BreakpointsView)));
 class BreakpointsDelegate {
     constructor(view) {
         this.view = view;
@@ -366,15 +376,16 @@ class BreakpointsDelegate {
         return '';
     }
 }
-const breakpointIdToActionBarDomeNode = ( new Map());
+const breakpointIdToActionBarDomeNode = ( (new Map()));
 let BreakpointsRenderer = class BreakpointsRenderer {
     static { BreakpointsRenderer_1 = this; }
-    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService, hoverService, labelService) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
         this.breakpointItemType = breakpointItemType;
         this.debugService = debugService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'breakpoints'; }
@@ -394,7 +405,7 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         append(data.breakpoint, data.checkbox);
         data.name = append(data.breakpoint, $('span.name'));
         data.filePath = append(data.breakpoint, $('span.file-path'));
-        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.actionBar = ( (new ActionBar(data.breakpoint)));
         data.toDispose.push(data.actionBar);
         const badgeContainer = append(data.breakpoint, $('.badge-container'));
         data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
@@ -404,7 +415,7 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         data.context = breakpoint;
         data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
         data.name.textContent = basenameOrAuthority(breakpoint.uri);
-        let badgeContent = ( breakpoint.lineNumber.toString());
+        let badgeContent = ( (breakpoint.lineNumber.toString()));
         if (breakpoint.column) {
             badgeContent += `:${breakpoint.column}`;
         }
@@ -416,7 +427,7 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         data.checkbox.checked = breakpoint.enabled;
         const { message, icon } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), breakpoint, this.labelService, this.debugService.getModel());
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
         const debugActive = this.debugService.state === 3  || this.debugService.state === 2 ;
         if (debugActive && !breakpoint.verified) {
             data.breakpoint.classList.add('disabled');
@@ -435,17 +446,19 @@ let BreakpointsRenderer = class BreakpointsRenderer {
         dispose(templateData.toDispose);
     }
 };
-BreakpointsRenderer = BreakpointsRenderer_1 = ( __decorate([
-    ( __param(4, IDebugService)),
-    ( __param(5, ILabelService))
-], BreakpointsRenderer));
+BreakpointsRenderer = BreakpointsRenderer_1 = ( (__decorate([
+    ( (__param(4, IDebugService))),
+    ( (__param(5, IHoverService))),
+    ( (__param(6, ILabelService)))
+], BreakpointsRenderer)));
 class ExceptionBreakpointsRenderer {
-    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService) {
+    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, debugService, hoverService) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
         this.breakpointItemType = breakpointItemType;
         this.debugService = debugService;
+        this.hoverService = hoverService;
     }
     static { this.ID = 'exceptionbreakpoints'; }
     get templateId() {
@@ -463,7 +476,7 @@ class ExceptionBreakpointsRenderer {
         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.actionBar = ( (new ActionBar(data.breakpoint)));
         data.toDispose.push(data.actionBar);
         const badgeContainer = append(data.breakpoint, $('.badge-container'));
         data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
@@ -472,21 +485,12 @@ class ExceptionBreakpointsRenderer {
     renderElement(exceptionBreakpoint, index, data) {
         data.context = exceptionBreakpoint;
         data.name.textContent = exceptionBreakpoint.label || `${exceptionBreakpoint.filter} exceptions`;
-        const exceptionBreakpointtitle = exceptionBreakpoint.verified ? (exceptionBreakpoint.description || data.name.textContent) : exceptionBreakpoint.message || ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'unverifiedExceptionBreakpoint',
-            "Unverified Exception Breakpoint"
-        ));
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, exceptionBreakpointtitle));
+        const exceptionBreakpointtitle = exceptionBreakpoint.verified ? (exceptionBreakpoint.description || data.name.textContent) : exceptionBreakpoint.message || ( localizeWithPath(_moduleId, 0, "Unverified Exception Breakpoint"));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, exceptionBreakpointtitle));
         data.breakpoint.classList.toggle('disabled', !exceptionBreakpoint.verified);
         data.checkbox.checked = exceptionBreakpoint.enabled;
         data.condition.textContent = exceptionBreakpoint.condition || '';
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.condition, ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'expressionCondition',
-            "Expression condition: {0}",
-            exceptionBreakpoint.condition
-        ))));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.condition, ( localizeWithPath(_moduleId, 1, "Expression condition: {0}", exceptionBreakpoint.condition))));
         if (exceptionBreakpoint.modeLabel) {
             data.badge.textContent = exceptionBreakpoint.modeLabel;
             data.badge.style.display = 'block';
@@ -509,11 +513,12 @@ class ExceptionBreakpointsRenderer {
 }
 let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
     static { FunctionBreakpointsRenderer_1 = this; }
-    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, labelService) {
+    constructor(menu, breakpointSupportsCondition, breakpointItemType, debugService, hoverService, labelService) {
         this.menu = menu;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
         this.breakpointItemType = breakpointItemType;
         this.debugService = debugService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'functionbreakpoints'; }
@@ -533,7 +538,7 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         append(data.breakpoint, data.checkbox);
         data.name = append(data.breakpoint, $('span.name'));
         data.condition = append(data.breakpoint, $('span.condition'));
-        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.actionBar = ( (new ActionBar(data.breakpoint)));
         data.toDispose.push(data.actionBar);
         const badgeContainer = append(data.breakpoint, $('.badge-container'));
         data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
@@ -544,13 +549,13 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         data.name.textContent = functionBreakpoint.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.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
         data.checkbox.checked = functionBreakpoint.enabled;
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
         if (functionBreakpoint.condition && functionBreakpoint.hitCondition) {
             data.condition.textContent = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'expressionAndHitCount',
+                _moduleId,
+                2,
                 "Condition: {0} | Hit Count: {1}",
                 functionBreakpoint.condition,
                 functionBreakpoint.hitCondition
@@ -569,11 +574,7 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         const session = this.debugService.getViewModel().focusedSession;
         data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsFunctionBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
         if (session && !session.capabilities.supportsFunctionBreakpoints) {
-            data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'functionBreakpointsNotSupported',
-                "Function breakpoints are not supported by this debug type"
-            ))));
+            data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localizeWithPath(_moduleId, 3, "Function breakpoints are not supported by this debug type"))));
         }
         const primary = [];
         this.breakpointSupportsCondition.set(!session || !!session.capabilities.supportsConditionalBreakpoints);
@@ -587,19 +588,21 @@ let FunctionBreakpointsRenderer = class FunctionBreakpointsRenderer {
         dispose(templateData.toDispose);
     }
 };
-FunctionBreakpointsRenderer = FunctionBreakpointsRenderer_1 = ( __decorate([
-    ( __param(3, IDebugService)),
-    ( __param(4, 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, labelService) {
+    constructor(menu, breakpointHasMultipleModes, breakpointSupportsCondition, breakpointItemType, breakpointIsDataBytes, debugService, hoverService, labelService) {
         this.menu = menu;
         this.breakpointHasMultipleModes = breakpointHasMultipleModes;
         this.breakpointSupportsCondition = breakpointSupportsCondition;
         this.breakpointItemType = breakpointItemType;
         this.breakpointIsDataBytes = breakpointIsDataBytes;
         this.debugService = debugService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'databreakpoints'; }
@@ -620,7 +623,7 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         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.actionBar = ( (new ActionBar(data.breakpoint)));
         data.toDispose.push(data.actionBar);
         const badgeContainer = append(data.breakpoint, $('.badge-container'));
         data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
@@ -631,9 +634,9 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         data.name.textContent = dataBreakpoint.description;
         const { icon, message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), dataBreakpoint, this.labelService, this.debugService.getModel());
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
         data.checkbox.checked = dataBreakpoint.enabled;
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, message ? message : ''));
         if (dataBreakpoint.modeLabel) {
             data.badge.textContent = dataBreakpoint.modeLabel;
             data.badge.style.display = 'block';
@@ -644,14 +647,10 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         const session = this.debugService.getViewModel().focusedSession;
         data.breakpoint.classList.toggle('disabled', (session && !session.capabilities.supportsDataBreakpoints) || !this.debugService.getModel().areBreakpointsActivated());
         if (session && !session.capabilities.supportsDataBreakpoints) {
-            data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointsNotSupported',
-                "Data breakpoints are not supported by this debug type"
-            ))));
+            data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, ( localizeWithPath(_moduleId, 4, "Data breakpoints are not supported by this debug type"))));
         }
         if (dataBreakpoint.accessType) {
-            const accessType = dataBreakpoint.accessType === 'read' ? ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'read', "Read")) : dataBreakpoint.accessType === 'write' ? ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'write', "Write")) : ( localizeWithPath('vs/workbench/contrib/debug/browser/breakpointsView', 'access', "Access"));
+            const accessType = dataBreakpoint.accessType === 'read' ? ( localizeWithPath(_moduleId, 5, "Read")) : dataBreakpoint.accessType === 'write' ? ( localizeWithPath(_moduleId, 6, "Write")) : ( localizeWithPath(_moduleId, 7, "Access"));
             data.accessType.textContent = accessType;
         }
         else {
@@ -659,8 +658,8 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         }
         if (dataBreakpoint.condition && dataBreakpoint.hitCondition) {
             data.condition.textContent = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'expressionAndHitCount',
+                _moduleId,
+                2,
                 "Condition: {0} | Hit Count: {1}",
                 dataBreakpoint.condition,
                 dataBreakpoint.hitCondition
@@ -684,14 +683,16 @@ let DataBreakpointsRenderer = class DataBreakpointsRenderer {
         dispose(templateData.toDispose);
     }
 };
-DataBreakpointsRenderer = DataBreakpointsRenderer_1 = ( __decorate([
-    ( __param(5, IDebugService)),
-    ( __param(6, ILabelService))
-], DataBreakpointsRenderer));
+DataBreakpointsRenderer = DataBreakpointsRenderer_1 = ( (__decorate([
+    ( (__param(5, IDebugService))),
+    ( (__param(6, IHoverService))),
+    ( (__param(7, ILabelService)))
+], DataBreakpointsRenderer)));
 let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
     static { InstructionBreakpointsRenderer_1 = this; }
-    constructor(debugService, labelService) {
+    constructor(debugService, hoverService, labelService) {
         this.debugService = debugService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'instructionBreakpoints'; }
@@ -711,7 +712,7 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
         append(data.breakpoint, data.checkbox);
         data.name = append(data.breakpoint, $('span.name'));
         data.address = append(data.breakpoint, $('span.file-path'));
-        data.actionBar = ( new ActionBar(data.breakpoint));
+        data.actionBar = ( (new ActionBar(data.breakpoint)));
         data.toDispose.push(data.actionBar);
         const badgeContainer = append(data.breakpoint, $('.badge-container'));
         data.badge = append(badgeContainer, $('span.line-number.monaco-count-badge'));
@@ -720,12 +721,12 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
     renderElement(breakpoint, index, data) {
         data.context = breakpoint;
         data.breakpoint.classList.toggle('disabled', !this.debugService.getModel().areBreakpointsActivated());
-        data.name.textContent = '0x' + ( breakpoint.address.toString(16));
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.name, `Decimal address: breakpoint.address.toString()`));
+        data.name.textContent = '0x' + ( (breakpoint.address.toString(16)));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.name, `Decimal address: 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());
         data.icon.className = ThemeIcon.asClassName(icon);
-        data.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.breakpoint, breakpoint.message || message || ''));
         const debugActive = this.debugService.state === 3  || this.debugService.state === 2 ;
         if (debugActive && !breakpoint.verified) {
             data.breakpoint.classList.add('disabled');
@@ -742,15 +743,17 @@ let InstructionBreakpointsRenderer = class InstructionBreakpointsRenderer {
         dispose(templateData.toDispose);
     }
 };
-InstructionBreakpointsRenderer = InstructionBreakpointsRenderer_1 = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, ILabelService))
-], InstructionBreakpointsRenderer));
+InstructionBreakpointsRenderer = InstructionBreakpointsRenderer_1 = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IHoverService))),
+    ( (__param(2, ILabelService)))
+], InstructionBreakpointsRenderer)));
 class FunctionBreakpointInputRenderer {
-    constructor(view, debugService, contextViewService, labelService) {
+    constructor(view, debugService, contextViewService, hoverService, labelService) {
         this.view = view;
         this.debugService = debugService;
         this.contextViewService = contextViewService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'functionbreakpointinput'; }
@@ -767,11 +770,11 @@ class FunctionBreakpointInputRenderer {
         append(breakpoint, template.checkbox);
         this.view.breakpointInputFocused.set(true);
         const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
-        const inputBox = ( new InputBox(
+        const inputBox = ( (new InputBox(
             inputBoxContainer,
             this.contextViewService,
             { inputBoxStyles: defaultInputBoxStyles }
-        ));
+        )));
         const wrapUp = (success) => {
             template.updating = true;
             try {
@@ -824,43 +827,27 @@ class FunctionBreakpointInputRenderer {
         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.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.icon, message ? message : ''));
         data.checkbox.checked = functionBreakpoint.enabled;
         data.checkbox.disabled = true;
         data.inputBox.value = functionBreakpoint.name || '';
-        let placeholder = ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'functionBreakpointPlaceholder',
-            "Function to break on"
-        ));
-        let ariaLabel = ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'functionBreakPointInputAriaLabel',
-            "Type function breakpoint."
-        ));
+        let placeholder = ( localizeWithPath(_moduleId, 8, "Function to break on"));
+        let ariaLabel = ( localizeWithPath(_moduleId, 9, "Type function breakpoint."));
         if (data.type === 'condition') {
             data.inputBox.value = functionBreakpoint.condition || '';
-            placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'functionBreakpointExpressionPlaceholder',
-                "Break when expression evaluates to true"
-            ));
+            placeholder = ( localizeWithPath(_moduleId, 10, "Break when expression evaluates to true"));
             ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'functionBreakPointExpresionAriaLabel',
+                _moduleId,
+                11,
                 "Type expression. Function breakpoint will break when expression evaluates to true"
             ));
         }
         else if (data.type === 'hitCount') {
             data.inputBox.value = functionBreakpoint.hitCondition || '';
-            placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'functionBreakpointHitCountPlaceholder',
-                "Break when hit count is met"
-            ));
+            placeholder = ( localizeWithPath(_moduleId, 12, "Break when hit count is met"));
             ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'functionBreakPointHitCountAriaLabel',
+                _moduleId,
+                13,
                 "Type hit count. Function breakpoint will break when hit count is met."
             ));
         }
@@ -876,10 +863,11 @@ class FunctionBreakpointInputRenderer {
     }
 }
 class DataBreakpointInputRenderer {
-    constructor(view, debugService, contextViewService, labelService) {
+    constructor(view, debugService, contextViewService, hoverService, labelService) {
         this.view = view;
         this.debugService = debugService;
         this.contextViewService = contextViewService;
+        this.hoverService = hoverService;
         this.labelService = labelService;
     }
     static { this.ID = 'databreakpointinput'; }
@@ -896,11 +884,11 @@ class DataBreakpointInputRenderer {
         append(breakpoint, template.checkbox);
         this.view.breakpointInputFocused.set(true);
         const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
-        const inputBox = ( new InputBox(
+        const inputBox = ( (new InputBox(
             inputBoxContainer,
             this.contextViewService,
             { inputBoxStyles: defaultInputBoxStyles }
-        ));
+        )));
         const wrapUp = (success) => {
             template.updating = true;
             try {
@@ -945,7 +933,7 @@ class DataBreakpointInputRenderer {
         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.toDispose.push(setupCustomHover(getDefaultHoverDelegate('mouse'), data.icon, message ?? ''));
+        data.toDispose.push(this.hoverService.setupUpdatableHover(getDefaultHoverDelegate('mouse'), data.icon, message ?? ''));
         data.checkbox.checked = dataBreakpoint.enabled;
         data.checkbox.disabled = true;
         data.inputBox.value = '';
@@ -953,27 +941,19 @@ class DataBreakpointInputRenderer {
         let ariaLabel = '';
         if (data.type === 'condition') {
             data.inputBox.value = dataBreakpoint.condition || '';
-            placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointExpressionPlaceholder',
-                "Break when expression evaluates to true"
-            ));
+            placeholder = ( localizeWithPath(_moduleId, 14, "Break when expression evaluates to true"));
             ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakPointExpresionAriaLabel',
+                _moduleId,
+                15,
                 "Type expression. Data breakpoint will break when expression evaluates to true"
             ));
         }
         else if (data.type === 'hitCount') {
             data.inputBox.value = dataBreakpoint.hitCondition || '';
-            placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointHitCountPlaceholder',
-                "Break when hit count is met"
-            ));
+            placeholder = ( localizeWithPath(_moduleId, 16, "Break when hit count is met"));
             ariaLabel = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakPointHitCountAriaLabel',
+                _moduleId,
+                17,
                 "Type hit count. Data breakpoint will break when hit count is met."
             ));
         }
@@ -1007,14 +987,10 @@ class ExceptionBreakpointInputRenderer {
         append(breakpoint, template.checkbox);
         this.view.breakpointInputFocused.set(true);
         const inputBoxContainer = append(breakpoint, $('.inputBoxContainer'));
-        const inputBox = ( new InputBox(inputBoxContainer, this.contextViewService, {
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'exceptionBreakpointAriaLabel',
-                "Type exception breakpoint condition"
-            )),
+        const inputBox = ( (new InputBox(inputBoxContainer, this.contextViewService, {
+            ariaLabel: ( localizeWithPath(_moduleId, 18, "Type exception breakpoint condition")),
             inputBoxStyles: defaultInputBoxStyles
-        }));
+        })));
         const wrapUp = (success) => {
             this.view.breakpointInputFocused.set(false);
             let newCondition = template.breakpoint.condition;
@@ -1042,11 +1018,7 @@ class ExceptionBreakpointInputRenderer {
         return template;
     }
     renderElement(exceptionBreakpoint, _index, data) {
-        const placeHolder = exceptionBreakpoint.conditionDescription || ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'exceptionBreakpointPlaceholder',
-            "Break when expression evaluates to true"
-        ));
+        const placeHolder = exceptionBreakpoint.conditionDescription || ( localizeWithPath(_moduleId, 19, "Break when expression evaluates to true"));
         data.inputBox.setPlaceHolder(placeHolder);
         data.breakpoint = exceptionBreakpoint;
         data.checkbox.checked = exceptionBreakpoint.enabled;
@@ -1067,11 +1039,7 @@ class BreakpointsAccessibilityProvider {
         this.labelService = labelService;
     }
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'breakpoints',
-            "Breakpoints"
-        ));
+        return ( localizeWithPath(_moduleId, 20, "Breakpoints"));
     }
     getRole() {
         return 'checkbox';
@@ -1081,10 +1049,12 @@ class BreakpointsAccessibilityProvider {
     }
     getAriaLabel(element) {
         if (element instanceof ExceptionBreakpoint) {
-            return ( element.toString());
+            return (
+                 (element.toString())
+            );
         }
         const { message } = getBreakpointMessageAndIcon(this.debugService.state, this.debugService.getModel().areBreakpointsActivated(), element, this.labelService, this.debugService.getModel());
-        const toString = ( element.toString());
+        const toString = ( (element.toString()));
         return message ? `${toString}, ${message}` : toString;
     }
 }
@@ -1120,15 +1090,7 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
     if (!breakpoint$1.enabled || !breakpointsActivated) {
         return {
             icon: breakpointIcon.disabled,
-            message: breakpoint$1.logMessage ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'disabledLogpoint',
-                "Disabled Logpoint"
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'disabledBreakpoint',
-                "Disabled Breakpoint"
-            )),
+            message: breakpoint$1.logMessage ? ( localizeWithPath(_moduleId, 21, "Disabled Logpoint")) : ( localizeWithPath(_moduleId, 22, "Disabled Breakpoint")),
         };
     }
     const appendMessage = (text) => {
@@ -1142,15 +1104,7 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
     if (debugActive && !breakpoint$1.verified) {
         return {
             icon: breakpointIcon.unverified,
-            message: ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : (breakpoint$1.logMessage ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'unverifiedLogpoint',
-                "Unverified Logpoint"
-            )) : ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'unverifiedBreakpoint',
-                "Unverified Breakpoint"
-            ))),
+            message: ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : (breakpoint$1.logMessage ? ( localizeWithPath(_moduleId, 23, "Unverified Logpoint")) : ( localizeWithPath(_moduleId, 24, "Unverified Breakpoint"))),
             showAdapterUnverifiedMessage: true
         };
     }
@@ -1158,54 +1112,28 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'dataBreakpointUnsupported',
-                    "Data breakpoints not supported by this debug type"
-                )),
+                message: ( localizeWithPath(_moduleId, 25, "Data breakpoints not supported by this debug type")),
             };
         }
         return {
             icon: breakpointIcon.regular,
-            message: breakpoint$1.message || ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpoint',
-                "Data Breakpoint"
-            ))
+            message: breakpoint$1.message || ( localizeWithPath(_moduleId, 26, "Data Breakpoint"))
         };
     }
     if (breakpoint$1 instanceof FunctionBreakpoint) {
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'functionBreakpointUnsupported',
-                    "Function breakpoints not supported by this debug type"
-                )),
+                message: ( localizeWithPath(_moduleId, 27, "Function breakpoints not supported by this debug type")),
             };
         }
         const messages = [];
-        messages.push(breakpoint$1.message || ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'functionBreakpoint',
-            "Function Breakpoint"
-        )));
+        messages.push(breakpoint$1.message || ( localizeWithPath(_moduleId, 28, "Function Breakpoint")));
         if (breakpoint$1.condition) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'expression',
-                "Condition: {0}",
-                breakpoint$1.condition
-            )));
+            messages.push(( localizeWithPath(_moduleId, 29, "Condition: {0}", breakpoint$1.condition)));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'hitCount',
-                "Hit Count: {0}",
-                breakpoint$1.hitCondition
-            )));
+            messages.push(( localizeWithPath(_moduleId, 30, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         return {
             icon: breakpointIcon.regular,
@@ -1216,11 +1144,7 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         if (!breakpoint$1.supported) {
             return {
                 icon: breakpointIcon.unverified,
-                message: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'instructionBreakpointUnsupported',
-                    "Instruction breakpoints not supported by this debug type"
-                )),
+                message: ( localizeWithPath(_moduleId, 31, "Instruction breakpoints not supported by this debug type")),
             };
         }
         const messages = [];
@@ -1229,26 +1153,17 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         }
         else if (breakpoint$1.instructionReference) {
             messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'instructionBreakpointAtAddress',
+                _moduleId,
+                32,
                 "Instruction breakpoint at address {0}",
                 breakpoint$1.instructionReference
             )));
         }
         else {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'instructionBreakpoint',
-                "Instruction breakpoint"
-            )));
+            messages.push(( localizeWithPath(_moduleId, 33, "Instruction breakpoint")));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'hitCount',
-                "Hit Count: {0}",
-                breakpoint$1.hitCondition
-            )));
+            messages.push(( localizeWithPath(_moduleId, 30, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         return {
             icon: breakpointIcon.regular,
@@ -1265,39 +1180,24 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
         if (!breakpoint$1.supported) {
             icon = debugBreakpointUnsupported;
             messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'breakpointUnsupported',
+                _moduleId,
+                34,
                 "Breakpoints of this type are not supported by the debugger"
             )));
         }
         if (breakpoint$1.logMessage) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'logMessage',
-                "Log Message: {0}",
-                breakpoint$1.logMessage
-            )));
+            messages.push(( localizeWithPath(_moduleId, 35, "Log Message: {0}", breakpoint$1.logMessage)));
         }
         if (breakpoint$1.condition) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'expression',
-                "Condition: {0}",
-                breakpoint$1.condition
-            )));
+            messages.push(( localizeWithPath(_moduleId, 29, "Condition: {0}", breakpoint$1.condition)));
         }
         if (breakpoint$1.hitCondition) {
-            messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'hitCount',
-                "Hit Count: {0}",
-                breakpoint$1.hitCondition
-            )));
+            messages.push(( localizeWithPath(_moduleId, 30, "Hit Count: {0}", breakpoint$1.hitCondition)));
         }
         if (triggeringBreakpoint) {
             messages.push(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'triggeredBy',
+                _moduleId,
+                36,
                 "Hit after breakpoint: {0}",
                 `${labelService.getUriLabel(triggeringBreakpoint.uri, { relative: true })}: ${triggeringBreakpoint.lineNumber}`
             )));
@@ -1307,11 +1207,7 @@ function getBreakpointMessageAndIcon(state, breakpointsActivated, breakpoint$1,
             message: appendMessage(messages.join('\n'))
         };
     }
-    const message = ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : breakpoint$1 instanceof Breakpoint && labelService ? labelService.getUriLabel(breakpoint$1.uri) : ( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/breakpointsView',
-        'breakpoint',
-        "Breakpoint"
-    ));
+    const message = ('message' in breakpoint$1 && breakpoint$1.message) ? breakpoint$1.message : breakpoint$1 instanceof Breakpoint && labelService ? labelService.getUriLabel(breakpoint$1.uri) : ( localizeWithPath(_moduleId, 37, "Breakpoint"));
     return {
         icon: breakpointIcon.regular,
         message
@@ -1322,16 +1218,8 @@ registerAction2(class extends Action2 {
         super({
             id: 'workbench.debug.viewlet.action.addFunctionBreakpointAction',
             title: {
-                ...( localize2WithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'addFunctionBreakpoint',
-                    "Add Function Breakpoint"
-                )),
-                mnemonicTitle: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    { key: 'miFunctionBreakpoint', comment: ['&& denotes a mnemonic'] },
-                    "&&Function Breakpoint..."
-                )),
+                ...( localize2WithPath(_moduleId, 38, "Add Function Breakpoint")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 39, "&&Function Breakpoint...")),
             },
             f1: true,
             icon: watchExpressionsAddFuncBreakpoint,
@@ -1339,7 +1227,7 @@ registerAction2(class extends Action2 {
                     id: MenuId.ViewTitle,
                     group: 'navigation',
                     order: 10,
-                    when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                    when: ( (ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID)))
                 }, {
                     id: MenuId.MenubarNewBreakpointMenu,
                     group: '1_breakpoints',
@@ -1376,8 +1264,8 @@ class MemoryBreakpointAction extends Action2 {
         }
         catch (e) {
             notifications.error(( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointError',
+                _moduleId,
+                40,
                 "Failed to set data breakpoint at {0}: {1}",
                 range.address,
                 e.message
@@ -1388,12 +1276,8 @@ class MemoryBreakpointAction extends Action2 {
         }
         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: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointAccessType',
-                "Select the access type to monitor"
-            )) });
+            const accessTypes = ( (info.accessTypes.map(type => ({ label: type }))));
+            const selectedAccessType = await quickInput.pick(accessTypes, { placeHolder: ( localizeWithPath(_moduleId, 41, "Select the access type to monitor")) });
             if (!selectedAccessType) {
                 return;
             }
@@ -1413,50 +1297,48 @@ class MemoryBreakpointAction extends Action2 {
         });
     }
     getRange(quickInput, defaultValue) {
-        return ( new Promise(resolve => {
-            const input = quickInput.createInputBox();
-            input.prompt = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointMemoryRangePrompt',
-                "Enter a memory range in which to break"
-            ));
-            input.placeholder = ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointMemoryRangePlaceholder',
-                'Absolute range (0x1234 - 0x1300) or range of bytes after an address (0x1234 + 0xff)'
-            ));
-            if (defaultValue) {
-                input.value = defaultValue;
-                input.valueSelection = [0, defaultValue.length];
-            }
-            input.onDidChangeValue(e => {
-                const err = this.parseAddress(e, false);
-                input.validationMessage = err?.error;
-            });
-            input.onDidAccept(() => {
-                const r = this.parseAddress(input.value, true);
-                if ('error' in r) {
-                    input.validationMessage = r.error;
-                }
-                else {
-                    resolve(r);
+        return (
+             (new Promise(resolve => {
+                const input = quickInput.createInputBox();
+                input.prompt = ( localizeWithPath(_moduleId, 42, "Enter a memory range in which to break"));
+                input.placeholder = ( localizeWithPath(
+                    _moduleId,
+                    43,
+                    'Absolute range (0x1234 - 0x1300) or range of bytes after an address (0x1234 + 0xff)'
+                ));
+                if (defaultValue) {
+                    input.value = defaultValue;
+                    input.valueSelection = [0, defaultValue.length];
                 }
-                input.dispose();
-            });
-            input.onDidHide(() => {
-                resolve(undefined);
-                input.dispose();
-            });
-            input.ignoreFocusOut = true;
-            input.show();
-        }));
+                input.onDidChangeValue(e => {
+                    const err = this.parseAddress(e, false);
+                    input.validationMessage = err?.error;
+                });
+                input.onDidAccept(() => {
+                    const r = this.parseAddress(input.value, true);
+                    if ('error' in r) {
+                        input.validationMessage = r.error;
+                    }
+                    else {
+                        resolve(r);
+                    }
+                    input.dispose();
+                });
+                input.onDidHide(() => {
+                    resolve(undefined);
+                    input.dispose();
+                });
+                input.ignoreFocusOut = true;
+                input.show();
+            }))
+        );
     }
     parseAddress(range, isFinal) {
         const parts = /^(\S+)\s*(?:([+-])\s*(\S+))?/.exec(range);
         if (!parts) {
             return { error: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'dataBreakpointAddrFormat',
+                _moduleId,
+                44,
                 'Address should be a range of numbers the form "[Start] - [End]" or "[Start] + [Bytes]"'
             )) };
         }
@@ -1465,8 +1347,8 @@ class MemoryBreakpointAction extends Action2 {
         for (const n of [startStr, endStr]) {
             if (!isNum(n)) {
                 return { error: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'dataBreakpointAddrStartEnd',
+                    _moduleId,
+                    45,
                     'Number must be a decimal integer or hex value starting with \"0x\", got {0}',
                     n
                 )) };
@@ -1477,7 +1359,7 @@ class MemoryBreakpointAction extends Action2 {
         }
         const start = BigInt(startStr);
         const end = BigInt(endStr);
-        const address = `0x${( start.toString(16))}`;
+        const address = `0x${( (start.toString(16)))}`;
         if (sign === '-') {
             return { address, bytes: Number(start - end) };
         }
@@ -1489,16 +1371,8 @@ registerAction2(class extends MemoryBreakpointAction {
         super({
             id: 'workbench.debug.viewlet.action.addDataBreakpointOnAddress',
             title: {
-                ...( localize2WithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'addDataBreakpointOnAddress',
-                    "Add Data Breakpoint at Address"
-                )),
-                mnemonicTitle: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    { key: 'miDataBreakpoint', comment: ['&& denotes a mnemonic'] },
-                    "&&Data Breakpoint..."
-                )),
+                ...( localize2WithPath(_moduleId, 46, "Add Data Breakpoint at Address")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 47, "&&Data Breakpoint...")),
             },
             f1: true,
             icon: watchExpressionsAddDataBreakpoint,
@@ -1506,7 +1380,10 @@ registerAction2(class extends MemoryBreakpointAction {
                     id: MenuId.ViewTitle,
                     group: 'navigation',
                     order: 11,
-                    when: ( ContextKeyExpr.and(CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED, ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))))
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED,
+                         (ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                    )))
                 }, {
                     id: MenuId.MenubarNewBreakpointMenu,
                     group: '1_breakpoints',
@@ -1520,17 +1397,13 @@ registerAction2(class extends MemoryBreakpointAction {
     constructor() {
         super({
             id: 'workbench.debug.viewlet.action.editDataBreakpointOnAddress',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editDataBreakpointOnAddress',
-                "Edit Address..."
-            )),
+            title: ( localize2WithPath(_moduleId, 48, "Edit Address...")),
             menu: [{
                     id: MenuId.DebugBreakpointsContext,
-                    when: ( ContextKeyExpr.and(
+                    when: ( (ContextKeyExpr.and(
                         CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED,
                         CONTEXT_BREAKPOINT_ITEM_IS_DATA_BYTES
-                    )),
+                    ))),
                     group: 'navigation',
                     order: 15,
                 }]
@@ -1541,18 +1414,14 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.debug.viewlet.action.toggleBreakpointsActivatedAction',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'activateBreakpoints',
-                'Toggle Activate Breakpoints'
-            )),
+            title: ( localize2WithPath(_moduleId, 49, 'Toggle Activate Breakpoints')),
             f1: true,
             icon: breakpointsActivate,
             menu: {
                 id: MenuId.ViewTitle,
                 group: 'navigation',
                 order: 20,
-                when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID)))
             }
         });
     }
@@ -1565,22 +1434,18 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.debug.viewlet.action.removeBreakpoint',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'removeBreakpoint',
-                "Remove Breakpoint"
-            )),
+            title: ( localizeWithPath(_moduleId, 50, "Remove Breakpoint")),
             icon: Codicon.removeClose,
             menu: [{
                     id: MenuId.DebugBreakpointsContext,
                     group: '3_modification',
                     order: 10,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    when: ( (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint')))
                 }, {
                     id: MenuId.DebugBreakpointsContext,
                     group: 'inline',
                     order: 20,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    when: ( (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint')))
                 }]
         });
     }
@@ -1605,16 +1470,8 @@ registerAction2(class extends Action2 {
         super({
             id: 'workbench.debug.viewlet.action.removeAllBreakpoints',
             title: {
-                ...( localize2WithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'removeAllBreakpoints',
-                    "Remove All Breakpoints"
-                )),
-                mnemonicTitle: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    { key: 'miRemoveAllBreakpoints', comment: ['&& denotes a mnemonic'] },
-                    "Remove &&All Breakpoints"
-                )),
+                ...( localize2WithPath(_moduleId, 51, "Remove All Breakpoints")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 52, "Remove &&All Breakpoints")),
             },
             f1: true,
             icon: breakpointsRemoveAll,
@@ -1622,12 +1479,15 @@ registerAction2(class extends Action2 {
                     id: MenuId.ViewTitle,
                     group: 'navigation',
                     order: 30,
-                    when: ( ContextKeyExpr.equals('view', BREAKPOINTS_VIEW_ID))
+                    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'))))
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_BREAKPOINTS_EXIST,
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    )))
                 }, {
                     id: MenuId.MenubarDebugMenu,
                     group: '5_breakpoints',
@@ -1649,16 +1509,8 @@ registerAction2(class extends Action2 {
         super({
             id: 'workbench.debug.viewlet.action.enableAllBreakpoints',
             title: {
-                ...( localize2WithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'enableAllBreakpoints',
-                    "Enable All Breakpoints"
-                )),
-                mnemonicTitle: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    { key: 'miEnableAllBreakpoints', comment: ['&& denotes a mnemonic'] },
-                    "&&Enable All Breakpoints"
-                )),
+                ...( localize2WithPath(_moduleId, 53, "Enable All Breakpoints")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 54, "&&Enable All Breakpoints")),
             },
             f1: true,
             precondition: CONTEXT_DEBUGGERS_AVAILABLE,
@@ -1666,7 +1518,10 @@ registerAction2(class extends Action2 {
                     id: MenuId.DebugBreakpointsContext,
                     group: 'z_commands',
                     order: 10,
-                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_BREAKPOINTS_EXIST,
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    )))
                 }, {
                     id: MenuId.MenubarDebugMenu,
                     group: '5_breakpoints',
@@ -1685,16 +1540,8 @@ registerAction2(class extends Action2 {
         super({
             id: 'workbench.debug.viewlet.action.disableAllBreakpoints',
             title: {
-                ...( localize2WithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'disableAllBreakpoints',
-                    "Disable All Breakpoints"
-                )),
-                mnemonicTitle: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    { key: 'miDisableAllBreakpoints', comment: ['&& denotes a mnemonic'] },
-                    "Disable A&&ll Breakpoints"
-                )),
+                ...( localize2WithPath(_moduleId, 55, "Disable All Breakpoints")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 56, "Disable A&&ll Breakpoints")),
             },
             f1: true,
             precondition: CONTEXT_DEBUGGERS_AVAILABLE,
@@ -1702,7 +1549,10 @@ registerAction2(class extends Action2 {
                     id: MenuId.DebugBreakpointsContext,
                     group: 'z_commands',
                     order: 20,
-                    when: ( ContextKeyExpr.and(CONTEXT_BREAKPOINTS_EXIST, ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))))
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_BREAKPOINTS_EXIST,
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    )))
                 }, {
                     id: MenuId.MenubarDebugMenu,
                     group: '5_breakpoints',
@@ -1720,18 +1570,17 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'workbench.debug.viewlet.action.reapplyBreakpointsAction',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'reapplyAllBreakpoints',
-                'Reapply All Breakpoints'
-            )),
+            title: ( localize2WithPath(_moduleId, 57, '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'))))
+                    when: ( (ContextKeyExpr.and(
+                        CONTEXT_BREAKPOINTS_EXIST,
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('exceptionBreakpoint'))
+                    )))
                 }]
         });
     }
@@ -1745,16 +1594,12 @@ registerAction2(class extends ViewAction {
         super({
             id: 'debug.editBreakpoint',
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editCondition',
-                "Edit Condition..."
-            )),
+            title: ( localizeWithPath(_moduleId, 58, "Edit Condition...")),
             icon: Codicon.edit,
             precondition: CONTEXT_BREAKPOINT_SUPPORTS_CONDITION,
             menu: [{
                     id: MenuId.DebugBreakpointsContext,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('functionBreakpoint')),
+                    when: ( (CONTEXT_BREAKPOINT_ITEM_TYPE.notEqualsTo('functionBreakpoint'))),
                     group: 'navigation',
                     order: 10
                 }, {
@@ -1778,16 +1623,8 @@ registerAction2(class extends ViewAction {
         }
         else if (breakpoint instanceof FunctionBreakpoint) {
             const contextMenuService = accessor.get(IContextMenuService);
-            const actions = [( new Action('breakpoint.editCondition', ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editCondition',
-                "Edit Condition..."
-            )), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'condition' }))),
-                ( new Action('breakpoint.editCondition', ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/breakpointsView',
-                    'editHitCount',
-                    "Edit Hit Count..."
-                )), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'hitCount' })))];
+            const actions = [( (new Action('breakpoint.editCondition', ( localizeWithPath(_moduleId, 58, "Edit Condition...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'condition' })))),
+                ( (new Action('breakpoint.editCondition', ( localizeWithPath(_moduleId, 59, "Edit Hit Count...")), undefined, true, async () => view.renderInputBox({ breakpoint, type: 'hitCount' }))))];
             const domNode = breakpointIdToActionBarDomeNode.get(breakpoint.getId());
             if (domNode) {
                 contextMenuService.showContextMenu({
@@ -1807,16 +1644,12 @@ registerAction2(class extends ViewAction {
         super({
             id: 'debug.editFunctionBreakpoint',
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editBreakpoint',
-                "Edit Function Condition..."
-            )),
+            title: ( localizeWithPath(_moduleId, 60, "Edit Function Condition...")),
             menu: [{
                     id: MenuId.DebugBreakpointsContext,
                     group: 'navigation',
                     order: 10,
-                    when: ( CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint'))
+                    when: ( (CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint')))
                 }]
         });
     }
@@ -1829,17 +1662,16 @@ registerAction2(class extends ViewAction {
         super({
             id: 'debug.editFunctionBreakpointHitCount',
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editHitCount',
-                "Edit Hit Count..."
-            )),
+            title: ( localizeWithPath(_moduleId, 59, "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'))))
+                    when: ( (ContextKeyExpr.or(
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('functionBreakpoint')),
+                         (CONTEXT_BREAKPOINT_ITEM_TYPE.isEqualTo('dataBreakpoint'))
+                    )))
                 }]
         });
     }
@@ -1852,16 +1684,16 @@ registerAction2(class extends ViewAction {
         super({
             id: 'debug.editBreakpointMode',
             viewId: BREAKPOINTS_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/breakpointsView',
-                'editMode',
-                "Edit Mode..."
-            )),
+            title: ( localizeWithPath(_moduleId, 61, "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'))))))
+                    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'))
+                    )))))
                 }]
         });
     }
@@ -1869,18 +1701,14 @@ registerAction2(class extends ViewAction {
         const kind = breakpoint instanceof Breakpoint ? 'source' : breakpoint instanceof InstructionBreakpoint ? 'instruction' : 'exception';
         const debugService = accessor.get(IDebugService);
         const modes = debugService.getModel().getBreakpointModes(kind);
-        const picked = await accessor.get(IQuickInputService).pick(( modes.map(
+        const picked = await accessor.get(IQuickInputService).pick(( (modes.map(
             mode => ({ label: mode.label, description: mode.description, mode: mode.mode })
-        )), { placeHolder: ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/breakpointsView',
-            'selectBreakpointMode',
-            "Select Breakpoint Mode"
-        )) });
+        ))), { placeHolder: ( localizeWithPath(_moduleId, 62, "Select Breakpoint Mode")) });
         if (!picked) {
             return;
         }
         if (kind === 'source') {
-            const data = ( new Map());
+            const data = ( (new Map()));
             data.set(breakpoint.getId(), { mode: picked.mode, modeLabel: picked.label });
             debugService.updateBreakpoints(breakpoint.originalUri, data, false);
         }