@codingame/monaco-vscode-debug-service-override 4.5.1 → 5.0.0

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

@@ -10,6 +10,7 @@ import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/c
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
@@ -27,20 +28,21 @@ 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;
 let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
-    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, menuService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+    constructor(options, contextMenuService, debugService, keybindingService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, themeService, telemetryService, hoverService, menuService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.debugService = debugService;
         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 +55,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,10 +70,8 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
                     return e.name;
                 }
             },
-            dnd: ( new WatchExpressionsDragAndDrop(this.debugService)),
-            overrideStyles: {
-                listBackground: this.getBackgroundColor()
-            }
+            dnd: ( (new WatchExpressionsDragAndDrop(this.debugService))),
+            overrideStyles: this.getLocationBasedColors().listOverrideStyles
         });
         this.tree.setInput(this.debugService);
         CONTEXT_WATCH_EXPRESSIONS_FOCUSED.bindTo(this.tree.contextKeyService);
@@ -176,19 +176,20 @@ 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, IHoverService))),
+    ( (__param(12, 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();
     }
@@ -225,8 +226,8 @@ class WatchExpressionsDataSource extends AbstractExpressionDataSource {
 let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractExpressionsRenderer {
     static { WatchExpressionsRenderer_1 = this; }
     static { this.ID = 'watchexpression'; }
-    constructor(menuService, contextKeyService, debugService, contextViewService) {
-        super(debugService, contextViewService);
+    constructor(menuService, contextKeyService, debugService, contextViewService, hoverService) {
+        super(debugService, contextViewService, hoverService);
         this.menuService = menuService;
         this.contextKeyService = contextKeyService;
     }
@@ -251,19 +252,15 @@ let WatchExpressionsRenderer = class WatchExpressionsRenderer extends AbstractEx
         renderExpressionValue(expression, data.value, {
             showChanged: true,
             maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
-            showHover: true,
+            hover: data.elementDisposable,
             colorize: true
-        });
+        }, this.hoverService);
     }
     getInputBoxOptions(expression, settingValue) {
         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,13 @@ 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))),
+    ( (__param(4, IHoverService)))
+], WatchExpressionsRenderer)));
 function getContextForWatchExpressionMenu(parentContext, expression) {
     return parentContext.createOverlay([
         [CONTEXT_CAN_VIEW_MEMORY.key, expression.memoryReference !== undefined],
@@ -325,29 +315,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 +373,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 +402,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 +410,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 +419,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 +430,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 +440,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 +453,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)))
             }
         });
     }

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

@@ -22,16 +22,18 @@ import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/edit
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { DEBUG_START_COMMAND_ID, SELECT_AND_START_ID, DEBUG_CONFIGURE_COMMAND_ID } from './debugCommands.js';
+import { DEBUG_START_COMMAND_ID, SELECT_AND_START_ID, DEBUG_CONFIGURE_COMMAND_ID } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugCommands';
+import { IHoverService } from 'vscode/vscode/vs/platform/hover/browser/hover.service';
 
+const _moduleId = "vs/workbench/contrib/debug/browser/welcomeView";
 const debugStartLanguageKey = 'debugStartLanguage';
-const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
-const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey('debuggerInterestedInActiveEditor', false));
+const CONTEXT_DEBUG_START_LANGUAGE = ( (new RawContextKey(debugStartLanguageKey, undefined)));
+const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( (new RawContextKey('debuggerInterestedInActiveEditor', false)));
 let WelcomeView = class WelcomeView extends ViewPane {
     static { this.ID = 'workbench.debug.welcome'; }
-    static { this.LABEL = ( localize2WithPath('vs/workbench/contrib/debug/browser/welcomeView', 'run', "Run")); }
-    constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, telemetryService) {
-        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+    static { this.LABEL = ( localize2WithPath(_moduleId, 0, "Run")); }
+    constructor(options, themeService, keybindingService, contextMenuService, configurationService, contextKeyService, debugService, editorService, instantiationService, viewDescriptorService, openerService, storageSevice, telemetryService, hoverService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, hoverService);
         this.debugService = debugService;
         this.editorService = editorService;
         this.debugStartLanguageContext = CONTEXT_DEBUG_START_LANGUAGE.bindTo(contextKeyService);
@@ -55,7 +57,7 @@ let WelcomeView = class WelcomeView extends ViewPane {
             }
             this.debuggerInterestedContext.set(false);
         };
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         this._register(disposables);
         this._register(editorService.onDidActiveEditorChange(() => {
             disposables.clear();
@@ -82,83 +84,81 @@ let WelcomeView = class WelcomeView extends ViewPane {
         return true;
     }
 };
-WelcomeView = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, IContextMenuService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IDebugService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IInstantiationService)),
-    ( __param(9, IViewDescriptorService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, IStorageService)),
-    ( __param(12, ITelemetryService))
-], WelcomeView));
-const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
+WelcomeView = ( (__decorate([
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IKeybindingService))),
+    ( (__param(3, IContextMenuService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IContextKeyService))),
+    ( (__param(6, IDebugService))),
+    ( (__param(7, IEditorService))),
+    ( (__param(8, IInstantiationService))),
+    ( (__param(9, IViewDescriptorService))),
+    ( (__param(10, IOpenerService))),
+    ( (__param(11, IStorageService))),
+    ( (__param(12, ITelemetryService))),
+    ( (__param(13, IHoverService)))
+], WelcomeView)));
+const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'openAFileWhichCanBeDebugged',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            '{Locked="](command:{0})"}'
-        ]
-    }, "[Open a file](command:{0}) which can be debugged or run.", (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFileAction.ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.toNegated()))),
+    content: ( localizeWithPath(
+        _moduleId,
+        1,
+        "[Open a file](command:{0}) which can be debugged or run.",
+        (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFileAction.ID
+    )),
+    when: ( (ContextKeyExpr.and(
+        CONTEXT_DEBUGGERS_AVAILABLE,
+         (CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR.toNegated())
+    ))),
     group: ViewContentGroups.Open,
 });
 let debugKeybindingLabel = '';
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'runAndDebugAction',
-        "Run and Debug"
-    ))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
+    content: `[${( localizeWithPath(_moduleId, 2, "Run and Debug"))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
     when: CONTEXT_DEBUGGERS_AVAILABLE,
     group: ViewContentGroups.Debug,
     order: 1
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'detectThenRunAndDebug',
-        "Show all automatic debug configurations"
-    ))}](command:${SELECT_AND_START_ID}).`,
+    content: `[${( localizeWithPath(_moduleId, 3, "Show all automatic debug configurations"))}](command:${SELECT_AND_START_ID}).`,
     when: CONTEXT_DEBUGGERS_AVAILABLE,
     group: ViewContentGroups.Debug,
     order: 10
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'customizeRunAndDebug',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            '{Locked="](command:{0})"}'
-        ]
-    }, "To customize Run and Debug [create a launch.json file](command:{0}).", DEBUG_CONFIGURE_COMMAND_ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.notEqualsTo('empty')))),
+    content: ( localizeWithPath(
+        _moduleId,
+        4,
+        "To customize Run and Debug [create a launch.json file](command:{0}).",
+        DEBUG_CONFIGURE_COMMAND_ID
+    )),
+    when: ( (ContextKeyExpr.and(
+        CONTEXT_DEBUGGERS_AVAILABLE,
+         (WorkbenchStateContext.notEqualsTo('empty'))
+    ))),
     group: ViewContentGroups.Debug
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
-        key: 'customizeRunAndDebugOpenFolder',
-        comment: [
-            'Please do not translate the word "command", it is part of our internal syntax which must not change',
-            'Please do not translate "launch.json", it is the specific configuration file name',
-            '{Locked="](command:{0})"}',
-        ]
-    }, "To customize Run and Debug, [open a folder](command:{0}) and create a launch.json file.", (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFolderAction.ID)),
-    when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.isEqualTo('empty')))),
+    content: ( localizeWithPath(
+        _moduleId,
+        5,
+        "To customize Run and Debug, [open a folder](command:{0}) and create a launch.json file.",
+        (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFolderAction.ID
+    )),
+    when: ( (ContextKeyExpr.and(
+        CONTEXT_DEBUGGERS_AVAILABLE,
+         (WorkbenchStateContext.isEqualTo('empty'))
+    ))),
     group: ViewContentGroups.Debug
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localizeWithPath(
-        'vs/workbench/contrib/debug/browser/welcomeView',
-        'allDebuggersDisabled',
+        _moduleId,
+        6,
         "All debug extensions are disabled. Enable a debug extension or install a new one from the Marketplace."
     )),
-    when: ( CONTEXT_DEBUG_EXTENSION_AVAILABLE.toNegated()),
+    when: ( (CONTEXT_DEBUG_EXTENSION_AVAILABLE.toNegated())),
     group: ViewContentGroups.Debug
 });
 

package/vscode/src/vs/workbench/contrib/debug/common/debugContentProvider.js

@@ -15,6 +15,7 @@ import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
 var DebugContentProvider_1;
+const _moduleId = "vs/workbench/contrib/debug/common/debugContentProvider";
 let DebugContentProvider = class DebugContentProvider {
     static { DebugContentProvider_1 = this; }
     constructor(textModelResolverService, debugService, modelService, languageService, editorWorkerService) {
@@ -22,7 +23,7 @@ let DebugContentProvider = class DebugContentProvider {
         this.modelService = modelService;
         this.languageService = languageService;
         this.editorWorkerService = editorWorkerService;
-        this.pendingUpdates = ( new Map());
+        this.pendingUpdates = ( (new Map()));
         textModelResolverService.registerTextModelContentProvider(DEBUG_SCHEME, this);
         DebugContentProvider_1.INSTANCE = this;
     }
@@ -49,29 +50,14 @@ let DebugContentProvider = class DebugContentProvider {
             session = this.debugService.getViewModel().focusedSession;
         }
         if (!session) {
-            return Promise.reject(( new ErrorNoTelemetry(( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'unable',
-                "Unable to resolve the resource without a debug session"
-            )))));
+            return Promise.reject(( (new ErrorNoTelemetry(( localizeWithPath(_moduleId, 0, "Unable to resolve the resource without a debug session"))))));
         }
         const createErrModel = (errMsg) => {
             this.debugService.sourceIsNotAvailable(resource);
             const languageSelection = this.languageService.createById(PLAINTEXT_LANGUAGE_ID);
             const message = errMsg
-                ? ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'canNotResolveSourceWithError',
-                "Could not load source '{0}': {1}.",
-                resource.path,
-                errMsg
-            ))
-                : ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugContentProvider',
-                'canNotResolveSource',
-                "Could not load source '{0}'.",
-                resource.path
-            ));
+                ? ( localizeWithPath(_moduleId, 1, "Could not load source '{0}': {1}.", resource.path, errMsg))
+                : ( localizeWithPath(_moduleId, 2, "Could not load source '{0}'.", resource.path));
             return this.modelService.createModel(message, languageSelection, resource);
         };
         return session.loadSource(resource).then(response => {
@@ -80,12 +66,12 @@ let DebugContentProvider = class DebugContentProvider {
                     const newContent = response.body.content;
                     const cancellationSource = this.pendingUpdates.get(model.id);
                     cancellationSource?.cancel();
-                    const myToken = ( new CancellationTokenSource());
+                    const myToken = ( (new CancellationTokenSource()));
                     this.pendingUpdates.set(model.id, myToken);
                     return this.editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: newContent, range: model.getFullModelRange() }]).then(edits => {
                         this.pendingUpdates.delete(model.id);
                         if (!myToken.token.isCancellationRequested && edits && edits.length > 0) {
-                            model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
+                            model.applyEdits(( (edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text)))));
                         }
                         return model;
                     });
@@ -100,12 +86,12 @@ let DebugContentProvider = class DebugContentProvider {
         }, (err) => createErrModel(err.message));
     }
 };
-DebugContentProvider = DebugContentProvider_1 = ( __decorate([
-    ( __param(0, ITextModelService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, IEditorWorkerService))
-], DebugContentProvider));
+DebugContentProvider = DebugContentProvider_1 = ( (__decorate([
+    ( (__param(0, ITextModelService))),
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IModelService))),
+    ( (__param(3, ILanguageService))),
+    ( (__param(4, IEditorWorkerService)))
+], DebugContentProvider)));
 
 export { DebugContentProvider };

package/vscode/src/vs/workbench/contrib/debug/common/debugLifecycle.js

@@ -5,6 +5,7 @@ import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 
+const _moduleId = "vs/workbench/contrib/debug/common/debugLifecycle";
 let DebugLifecycle = class DebugLifecycle {
     constructor(lifecycleService, debugService, configurationService, dialogService) {
         this.debugService = debugService;
@@ -27,35 +28,31 @@ let DebugLifecycle = class DebugLifecycle {
         let message;
         if (numSessions === 1) {
             message = ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                'debug.debugSessionCloseConfirmationSingular',
+                _moduleId,
+                0,
                 "There is an active debug session, are you sure you want to stop it?"
             ));
         }
         else {
             message = ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                'debug.debugSessionCloseConfirmationPlural',
+                _moduleId,
+                1,
                 "There are active debug sessions, are you sure you want to stop them?"
             ));
         }
         const res = await this.dialogService.confirm({
             message,
             type: 'warning',
-            primaryButton: ( localizeWithPath(
-                'vs/workbench/contrib/debug/common/debugLifecycle',
-                { key: 'debug.stop', comment: ['&& denotes a mnemonic'] },
-                "&&Stop Debugging"
-            ))
+            primaryButton: ( localizeWithPath(_moduleId, 2, "&&Stop Debugging"))
         });
         return !res.confirmed;
     }
 };
-DebugLifecycle = ( __decorate([
-    ( __param(0, ILifecycleService)),
-    ( __param(1, IDebugService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IDialogService))
-], DebugLifecycle));
+DebugLifecycle = ( (__decorate([
+    ( (__param(0, ILifecycleService))),
+    ( (__param(1, IDebugService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IDialogService)))
+], DebugLifecycle)));
 
 export { DebugLifecycle };