@codingame/monaco-vscode-debug-service-override 4.5.0 → 4.5.2

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

@@ -19,14 +19,15 @@ import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService.service';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/statusbarColorProvider";
 const STATUS_BAR_DEBUGGING_BACKGROUND = registerColor('statusBar.debuggingBackground', {
     dark: '#CC6633',
     light: '#CC6633',
     hcDark: '#BA592C',
     hcLight: '#B5200D'
 }, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
-    'statusBarDebuggingBackground',
+    _moduleId,
+    0,
     "Status bar background color when a program is being debugged. The status bar is shown in the bottom of the window"
 )));
 const STATUS_BAR_DEBUGGING_FOREGROUND = registerColor('statusBar.debuggingForeground', {
@@ -35,8 +36,8 @@ const STATUS_BAR_DEBUGGING_FOREGROUND = registerColor('statusBar.debuggingForegr
     hcDark: STATUS_BAR_FOREGROUND,
     hcLight: '#FFFFFF'
 }, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
-    'statusBarDebuggingForeground',
+    _moduleId,
+    1,
     "Status bar foreground color when a program is being debugged. The status bar is shown in the bottom of the window"
 )));
 const STATUS_BAR_DEBUGGING_BORDER = registerColor('statusBar.debuggingBorder', {
@@ -45,8 +46,8 @@ const STATUS_BAR_DEBUGGING_BORDER = registerColor('statusBar.debuggingBorder', {
     hcDark: STATUS_BAR_BORDER,
     hcLight: STATUS_BAR_BORDER
 }, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
-    'statusBarDebuggingBorder',
+    _moduleId,
+    2,
     "Status bar border color separating to the sidebar and editor when a program is being debugged. The status bar is shown in the bottom of the window"
 )));
 const COMMAND_CENTER_DEBUGGING_BACKGROUND = registerColor('commandCenter.debuggingBackground', {
@@ -55,8 +56,8 @@ const COMMAND_CENTER_DEBUGGING_BACKGROUND = registerColor('commandCenter.debuggi
     light: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 },
     hcLight: { value: STATUS_BAR_DEBUGGING_BACKGROUND, op: 2 , factor: 0.258 }
 }, ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/statusbarColorProvider',
-    'commandCenter-activeBackground',
+    _moduleId,
+    3,
     "Command center background color when a program is being debugged"
 )), true);
 let StatusBarColorProvider = class StatusBarColorProvider {
@@ -83,7 +84,7 @@ let StatusBarColorProvider = class StatusBarColorProvider {
         this.statusbarService = statusbarService;
         this.layoutService = layoutService;
         this.configurationService = configurationService;
-        this.disposables = ( new DisposableStore());
+        this.disposables = ( (new DisposableStore()));
         this.debugService.onDidChangeState(this.update, this, this.disposables);
         this.contextService.onDidChangeWorkbenchState(this.update, this, this.disposables);
         this.configurationService.onDidChangeConfiguration((e) => {
@@ -112,13 +113,13 @@ let StatusBarColorProvider = class StatusBarColorProvider {
         this.disposables.dispose();
     }
 };
-StatusBarColorProvider = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IStatusbarService)),
-    ( __param(3, ILayoutService)),
-    ( __param(4, IConfigurationService))
-], StatusBarColorProvider));
+StatusBarColorProvider = ( (__decorate([
+    ( (__param(0, IDebugService))),
+    ( (__param(1, IWorkspaceContextService))),
+    ( (__param(2, IStatusbarService))),
+    ( (__param(3, ILayoutService))),
+    ( (__param(4, IConfigurationService)))
+], StatusBarColorProvider)));
 function isStatusbarInDebugMode(state, sessions) {
     if (state === 0  || state === 1  || sessions.every(s => s.suppressDebugStatusbar || s.configuration?.noDebug)) {
         return false;

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

@@ -41,6 +41,7 @@ import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/commo
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
 var VisualizedVariableRenderer_1, VariablesRenderer_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/variablesView";
 const $ = $$1;
 let forgetScopes = true;
 let variableInternalContext;
@@ -51,9 +52,9 @@ let VariablesView = class VariablesView extends ViewPane {
         this.debugService = debugService;
         this.menuService = menuService;
         this.needsRefresh = false;
-        this.savedViewState = ( new Map());
-        this.autoExpandedScopes = ( new Set());
-        this.updateTreeScheduler = ( new RunOnceScheduler(async () => {
+        this.savedViewState = ( (new Map()));
+        this.autoExpandedScopes = ( (new Set()));
+        this.updateTreeScheduler = ( (new RunOnceScheduler(async () => {
             const stackFrame = this.debugService.getViewModel().focusedStackFrame;
             this.needsRefresh = false;
             const input = this.tree.getInput();
@@ -72,7 +73,7 @@ let VariablesView = class VariablesView extends ViewPane {
                 this.autoExpandedScopes.add(toExpand.getId());
                 await this.tree.expand(toExpand);
             }
-        }, 400));
+        }, 400)));
     }
     renderBody(container) {
         super.renderBody(container);
@@ -80,13 +81,13 @@ let VariablesView = class VariablesView extends ViewPane {
         container.classList.add('debug-variables');
         const treeContainer = renderViewTree(container);
         const linkDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( (new VariablesDelegate())), [
             this.instantiationService.createInstance(VariablesRenderer, linkDetector),
             this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
-            ( new ScopesRenderer()),
-            ( new ScopeErrorRenderer()),
+            ( (new ScopesRenderer())),
+            ( (new ScopeErrorRenderer())),
         ], this.instantiationService.createInstance(VariablesDataSource), {
-            accessibilityProvider: ( new VariablesAccessibilityProvider()),
+            accessibilityProvider: ( (new VariablesAccessibilityProvider())),
             identityProvider: { getId: (element) => element.getId() },
             keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
             overrideStyles: {
@@ -180,25 +181,25 @@ let VariablesView = class VariablesView extends ViewPane {
         return openContextMenuForVariableTreeElement(this.contextKeyService, this.menuService, this.contextMenuService, MenuId.DebugVariablesContext, e);
     }
 };
-VariablesView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IViewDescriptorService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, IMenuService))
-], VariablesView));
+VariablesView = ( (__decorate([
+    ( (__param(1, IContextMenuService))),
+    ( (__param(2, IDebugService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IViewDescriptorService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IOpenerService))),
+    ( (__param(9, IThemeService))),
+    ( (__param(10, ITelemetryService))),
+    ( (__param(11, IMenuService)))
+], VariablesView)));
 async function openContextMenuForVariableTreeElement(parentContextKeyService, menuService, contextMenuService, menuId, e) {
     const variable = e.element;
     if (!(variable instanceof Variable) || !variable.value) {
         return;
     }
-    const toDispose = ( new DisposableStore());
+    const toDispose = ( (new DisposableStore()));
     try {
         const contextKeyService = await getContextForVariableMenuWithDataAccess(parentContextKeyService, variable);
         const menu = toDispose.add(menuService.createMenu(menuId, contextKeyService));
@@ -298,7 +299,7 @@ class ScopesRenderer {
     }
     renderTemplate(container) {
         const name = append(container, $('.scope'));
-        const label = ( new HighlightedLabel(name));
+        const label = ( (new HighlightedLabel(name)));
         return { name, label };
     }
     renderElement(element, index, templateData) {
@@ -367,11 +368,7 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         const viz = expression;
         return {
             initialValue: expression.value,
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableValueAriaLabel',
-                "Type new variable value"
-            )),
+            ariaLabel: ( localizeWithPath(_moduleId, 0, "Type new variable value")),
             validationOptions: {
                 validation: () => viz.errorMessage ? ({ content: viz.errorMessage }) : null
             },
@@ -394,11 +391,7 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         const context = viz.original ? getVariablesContext(viz.original) : undefined;
         createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
         if (viz.original) {
-            const action = ( new Action('debugViz', ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'removeVisualizer',
-                'Remove Visualizer'
-            )), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined)));
+            const action = ( (new Action('debugViz', ( localizeWithPath(_moduleId, 1, 'Remove Visualizer')), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined))));
             action.checked = true;
             primary.push(action);
             actionBar.domNode.style.display = 'initial';
@@ -408,12 +401,12 @@ let VisualizedVariableRenderer = class VisualizedVariableRenderer extends Abstra
         actionBar.push(primary, { icon: true, label: false });
     }
 };
-VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( __decorate([
-    ( __param(1, IDebugService)),
-    ( __param(2, IContextViewService)),
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService))
-], VisualizedVariableRenderer));
+VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( (__decorate([
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IContextViewService))),
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextKeyService)))
+], VisualizedVariableRenderer)));
 let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRenderer {
     static { VariablesRenderer_1 = this; }
     static { this.ID = 'variable'; }
@@ -438,11 +431,7 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         const variable = expression;
         return {
             initialValue: expression.value,
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableValueAriaLabel',
-                "Type new variable value"
-            )),
+            ariaLabel: ( localizeWithPath(_moduleId, 0, "Type new variable value")),
             validationOptions: {
                 validation: () => variable.errorMessage ? ({ content: variable.errorMessage }) : null
             },
@@ -469,28 +458,24 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         actionBar.clear();
         actionBar.context = context;
         actionBar.push(primary, { icon: true, label: false });
-        const cts = ( new CancellationTokenSource());
+        const cts = ( (new CancellationTokenSource()));
         data.elementDisposable.add(toDisposable(() => cts.dispose(true)));
         this.visualization.getApplicableFor(expression, cts.token).then(result => {
             data.elementDisposable.add(result);
             const originalExpression = (expression instanceof VisualizedExpression && expression.original) || expression;
-            const actions = ( result.object.map(v => ( new Action(
+            const actions = ( (result.object.map(v => ( (new Action(
                 'debugViz',
                 v.name,
                 v.iconClass || 'debug-viz-icon',
                 undefined,
                 this.useVisualizer(v, originalExpression, cts.token)
-            ))));
+            ))))));
             if (actions.length === 0) ;
             else if (actions.length === 1) {
                 actionBar.push(actions[0], { icon: true, label: false });
             }
             else {
-                actionBar.push(( new Action('debugViz', ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/variablesView',
-                    'useVisualizer',
-                    'Visualize Variable...'
-                )), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data))), { icon: true, label: false });
+                actionBar.push(( (new Action('debugViz', ( localizeWithPath(_moduleId, 2, 'Visualize Variable...')), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data)))), { icon: true, label: false });
             }
         });
     }
@@ -518,39 +503,24 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         };
     }
 };
-VariablesRenderer = VariablesRenderer_1 = ( __decorate([
-    ( __param(1, IMenuService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IDebugVisualizerService)),
-    ( __param(4, IContextMenuService)),
-    ( __param(5, IDebugService)),
-    ( __param(6, IContextViewService))
-], VariablesRenderer));
+VariablesRenderer = VariablesRenderer_1 = ( (__decorate([
+    ( (__param(1, IMenuService))),
+    ( (__param(2, IContextKeyService))),
+    ( (__param(3, IDebugVisualizerService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IDebugService))),
+    ( (__param(6, IContextViewService)))
+], VariablesRenderer)));
 class VariablesAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/variablesView',
-            'variablesAriaTreeLabel',
-            "Debug Variables"
-        ));
+        return ( localizeWithPath(_moduleId, 3, "Debug Variables"));
     }
     getAriaLabel(element) {
         if (element instanceof Scope) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'variableScopeAriaLabel',
-                "Scope {0}",
-                element.name
-            ));
+            return ( localizeWithPath(_moduleId, 4, "Scope {0}", element.name));
         }
         if (element instanceof Variable) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                { key: 'variableAriaLabel', comment: ['Placeholders are variable name and variable value respectivly. They should not be translated.'] },
-                "{0}, value {1}",
-                element.name,
-                element.value
-            ));
+            return ( localizeWithPath(_moduleId, 5, "{0}, value {1}", element.name, element.value));
         }
         return null;
     }
@@ -585,18 +555,18 @@ CommandsRegistry.registerCommand({
             return;
         }
         const evalContext = session.capabilities.supportsClipboardContext ? 'clipboard' : elementContext;
-        const toEvaluate = ( elements.map(
+        const toEvaluate = ( (elements.map(
             element => element instanceof Variable ? (element.evaluateName || element.value) : element.name
-        ));
+        )));
         try {
-            const evaluations = await Promise.all(( toEvaluate.map(expr => session.evaluate(expr, stackFrame.frameId, evalContext))));
-            const result = ( coalesce(evaluations).map(evaluation => evaluation.body.result));
+            const evaluations = await Promise.all(( (toEvaluate.map(expr => session.evaluate(expr, stackFrame.frameId, evalContext)))));
+            const result = ( (coalesce(evaluations).map(evaluation => evaluation.body.result)));
             if (result.length) {
                 clipboardService.writeText(result.join('\n'));
             }
         }
         catch (e) {
-            const result = ( elements.map(element => element.value));
+            const result = ( (elements.map(element => element.value)));
             clipboardService.writeText(result.join('\n'));
         }
     }
@@ -651,11 +621,7 @@ CommandsRegistry.registerCommand({
 async function tryInstallHexEditor(extensionsWorkbenchService, notificationService) {
     try {
         await extensionsWorkbenchService.install(HEX_EDITOR_EXTENSION_ID, {
-            justification: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                "viewMemory.prompt",
-                "Inspecting binary data requires this extension."
-            )),
+            justification: ( localizeWithPath(_moduleId, 6, "Inspecting binary data requires this extension.")),
             enable: true
         }, 15 );
         return true;
@@ -716,17 +682,13 @@ registerAction2(class extends ViewAction {
         super({
             id: 'variables.collapse',
             viewId: VARIABLES_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/variablesView',
-                'collapse',
-                "Collapse All"
-            )),
+            title: ( localizeWithPath(_moduleId, 7, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             menu: {
                 id: MenuId.ViewTitle,
                 group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', VARIABLES_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', VARIABLES_VIEW_ID)))
             }
         });
     }

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

@@ -27,6 +27,7 @@ import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/d
 import { Expression, Variable, VisualizedExpression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 
 var WatchExpressionsRenderer_1;
+const _moduleId = "vs/workbench/contrib/debug/browser/watchExpressionsView";
 const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
 let ignoreViewUpdates = false;
 let useCachedEvaluation = false;
@@ -37,10 +38,10 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         this.needsRefresh = false;
         this.menu = menuService.createMenu(MenuId.DebugWatchContext, contextKeyService);
         this._register(this.menu);
-        this.watchExpressionsUpdatedScheduler = ( new RunOnceScheduler(() => {
+        this.watchExpressionsUpdatedScheduler = ( (new RunOnceScheduler(() => {
             this.needsRefresh = false;
             this.tree.updateChildren();
-        }, 50));
+        }, 50)));
         this.watchExpressionsExist = CONTEXT_WATCH_EXPRESSIONS_EXIST.bindTo(contextKeyService);
         this.variableReadonly = CONTEXT_VARIABLE_IS_READONLY.bindTo(contextKeyService);
         this.watchExpressionsExist.set(this.debugService.getModel().getWatchExpressions().length > 0);
@@ -53,12 +54,12 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         const treeContainer = renderViewTree(container);
         const expressionsRenderer = this.instantiationService.createInstance(WatchExpressionsRenderer);
         const linkDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( (new WatchExpressionsDelegate())), [
             expressionsRenderer,
             this.instantiationService.createInstance(VariablesRenderer, linkDetector),
             this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
         ], this.instantiationService.createInstance(WatchExpressionsDataSource), {
-            accessibilityProvider: ( new WatchExpressionsAccessibilityProvider()),
+            accessibilityProvider: ( (new WatchExpressionsAccessibilityProvider())),
             identityProvider: { getId: (element) => element.getId() },
             keyboardNavigationLabelProvider: {
                 getKeyboardNavigationLabel: (e) => {
@@ -68,7 +69,7 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
                     return e.name;
                 }
             },
-            dnd: ( new WatchExpressionsDragAndDrop(this.debugService)),
+            dnd: ( (new WatchExpressionsDragAndDrop(this.debugService))),
             overrideStyles: {
                 listBackground: this.getBackgroundColor()
             }
@@ -176,19 +177,19 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         });
     }
 };
-WatchExpressionsView = ( __decorate([
-    ( __param(1, IContextMenuService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IViewDescriptorService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IContextKeyService)),
-    ( __param(8, IOpenerService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, IMenuService))
-], WatchExpressionsView));
+WatchExpressionsView = ( (__decorate([
+    ( (__param(1, IContextMenuService))),
+    ( (__param(2, IDebugService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IInstantiationService))),
+    ( (__param(5, IViewDescriptorService))),
+    ( (__param(6, IConfigurationService))),
+    ( (__param(7, IContextKeyService))),
+    ( (__param(8, IOpenerService))),
+    ( (__param(9, IThemeService))),
+    ( (__param(10, ITelemetryService))),
+    ( (__param(11, IMenuService)))
+], WatchExpressionsView)));
 class WatchExpressionsDelegate {
     getHeight(_element) {
         return 22;
@@ -215,9 +216,9 @@ class WatchExpressionsDataSource extends AbstractExpressionDataSource {
             const debugService = element;
             const watchExpressions = debugService.getModel().getWatchExpressions();
             const viewModel = debugService.getViewModel();
-            return Promise.all(( watchExpressions.map(we => !!we.name && !useCachedEvaluation
+            return Promise.all(( (watchExpressions.map(we => !!we.name && !useCachedEvaluation
                 ? we.evaluate(viewModel.focusedSession, viewModel.focusedStackFrame, 'watch').then(() => we)
-                : Promise.resolve(we))));
+                : Promise.resolve(we)))));
         }
         return element.getChildren();
     }
@@ -259,11 +260,7 @@ let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractEx
         if (settingValue) {
             return {
                 initialValue: expression.value,
-                ariaLabel: ( localizeWithPath(
-                    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                    'typeNewValue',
-                    "Type new value"
-                )),
+                ariaLabel: ( localizeWithPath(_moduleId, 0, "Type new value")),
                 onFinish: async (value, success) => {
                     if (success && value) {
                         const focusedFrame = this.debugService.getViewModel().focusedStackFrame;
@@ -277,16 +274,8 @@ let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractEx
         }
         return {
             initialValue: expression.name ? expression.name : '',
-            ariaLabel: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'watchExpressionInputAriaLabel',
-                "Type watch expression"
-            )),
-            placeholder: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'watchExpressionPlaceholder',
-                "Expression to watch"
-            )),
+            ariaLabel: ( localizeWithPath(_moduleId, 1, "Type watch expression")),
+            placeholder: ( localizeWithPath(_moduleId, 2, "Expression to watch")),
             onFinish: (value, success) => {
                 if (success && value) {
                     this.debugService.renameWatchExpression(expression.getId(), value);
@@ -311,12 +300,12 @@ let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractEx
         actionBar.push(primary, { icon: true, label: false });
     }
 };
-WatchExpressionsRenderer = WatchExpressionsRenderer_1 = ( __decorate([
-    ( __param(0, IMenuService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IDebugService)),
-    ( __param(3, IContextViewService))
-], WatchExpressionsRenderer));
+WatchExpressionsRenderer = WatchExpressionsRenderer_1 = ( (__decorate([
+    ( (__param(0, IMenuService))),
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IDebugService))),
+    ( (__param(3, IContextViewService)))
+], WatchExpressionsRenderer)));
 function getContextForWatchExpressionMenu(parentContext, expression) {
     return parentContext.createOverlay([
         [CONTEXT_CAN_VIEW_MEMORY.key, expression.memoryReference !== undefined],
@@ -325,29 +314,13 @@ function getContextForWatchExpressionMenu(parentContext, expression) {
 }
 class WatchExpressionsAccessibilityProvider {
     getWidgetAriaLabel() {
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/watchExpressionsView',
-            { comment: ['Debug is a noun in this context, not a verb.'], key: 'watchAriaTreeLabel' },
-            "Debug Watch Expressions"
-        ));
+        return ( localizeWithPath(_moduleId, 3, "Debug Watch Expressions"));
     }
     getAriaLabel(element) {
         if (element instanceof Expression) {
-            return ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'watchExpressionAriaLabel',
-                "{0}, value {1}",
-                element.name,
-                element.value
-            ));
+            return ( localizeWithPath(_moduleId, 4, "{0}, value {1}", element.name, element.value));
         }
-        return ( localizeWithPath(
-            'vs/workbench/contrib/debug/browser/watchExpressionsView',
-            'watchVariableAriaLabel',
-            "{0}, value {1}",
-            element.name,
-            element.value
-        ));
+        return ( localizeWithPath(_moduleId, 5, "{0}, value {1}", element.name, element.value));
     }
 }
 class WatchExpressionsDragAndDrop {
@@ -399,7 +372,7 @@ class WatchExpressionsDragAndDrop {
         }
         const draggedElement = data.elements[0];
         if (!(draggedElement instanceof Expression)) {
-            throw new Error('Invalid dragged element');
+            throw ( (new Error('Invalid dragged element')));
         }
         const watches = this.debugService.getModel().getWatchExpressions();
         const sourcePosition = watches.indexOf(draggedElement);
@@ -428,11 +401,7 @@ registerAction2(class Collapse extends ViewAction {
         super({
             id: 'watch.collapse',
             viewId: WATCH_VIEW_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/debug/browser/watchExpressionsView',
-                'collapse',
-                "Collapse All"
-            )),
+            title: ( localizeWithPath(_moduleId, 6, "Collapse All")),
             f1: false,
             icon: Codicon.collapseAll,
             precondition: CONTEXT_WATCH_EXPRESSIONS_EXIST,
@@ -440,7 +409,7 @@ registerAction2(class Collapse extends ViewAction {
                 id: MenuId.ViewTitle,
                 order: 30,
                 group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', WATCH_VIEW_ID)))
             }
         });
     }
@@ -449,11 +418,7 @@ registerAction2(class Collapse extends ViewAction {
     }
 });
 const ADD_WATCH_ID = 'workbench.debug.viewlet.action.addWatchExpression';
-const ADD_WATCH_LABEL = ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-    'addWatchExpression',
-    "Add Expression"
-));
+const ADD_WATCH_LABEL = ( localizeWithPath(_moduleId, 7, "Add Expression"));
 registerAction2(class AddWatchExpressionAction extends Action2 {
     constructor() {
         super({
@@ -464,7 +429,7 @@ registerAction2(class AddWatchExpressionAction extends Action2 {
             menu: {
                 id: MenuId.ViewTitle,
                 group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', WATCH_VIEW_ID)))
             }
         });
     }
@@ -474,11 +439,7 @@ registerAction2(class AddWatchExpressionAction extends Action2 {
     }
 });
 const REMOVE_WATCH_EXPRESSIONS_COMMAND_ID = 'workbench.debug.viewlet.action.removeAllWatchExpressions';
-const REMOVE_WATCH_EXPRESSIONS_LABEL = ( localizeWithPath(
-    'vs/workbench/contrib/debug/browser/watchExpressionsView',
-    'removeAllWatchExpressions',
-    "Remove All Expressions"
-));
+const REMOVE_WATCH_EXPRESSIONS_LABEL = ( localizeWithPath(_moduleId, 8, "Remove All Expressions"));
 registerAction2(class RemoveAllWatchExpressionsAction extends Action2 {
     constructor() {
         super({
@@ -491,7 +452,7 @@ registerAction2(class RemoveAllWatchExpressionsAction extends Action2 {
                 id: MenuId.ViewTitle,
                 order: 20,
                 group: 'navigation',
-                when: ( ContextKeyExpr.equals('view', WATCH_VIEW_ID))
+                when: ( (ContextKeyExpr.equals('view', WATCH_VIEW_ID)))
             }
         });
     }