@codingame/monaco-vscode-debug-service-override 1.83.2 → 1.83.3

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

@@ -12,7 +12,7 @@ import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
@@ -263,7 +263,7 @@ let DebugSession = class DebugSession {
     }
     async launchOrAttach(config) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'launch or attach'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'launch or attach'));
         }
         if (this.parentSession && this.parentSession.state === 0 ) {
             throw canceled();
@@ -314,7 +314,7 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'restart'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restart'));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -326,7 +326,7 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints'));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -356,7 +356,7 @@ let DebugSession = class DebugSession {
     }
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'function breakpoints'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'function breakpoints'));
         }
         if (this.raw.readyForBreakpoints) {
             const response = await this.raw.setFunctionBreakpoints({ breakpoints: fbpts });
@@ -371,7 +371,7 @@ let DebugSession = class DebugSession {
     }
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'exception breakpoints'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exception breakpoints'));
         }
         if (this.raw.readyForBreakpoints) {
             const args = this.capabilities.supportsExceptionFilterOptions ? {
@@ -395,17 +395,17 @@ let DebugSession = class DebugSession {
     }
     async dataBreakpointInfo(name, variablesReference) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints info'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints info'));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw new Error(localize('sessionNotReadyForBreakpoints', "Session is not ready for breakpoints"));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'sessionNotReadyForBreakpoints', "Session is not ready for breakpoints"));
         }
         const response = await this.raw.dataBreakpointInfo({ name, variablesReference });
         return response?.body;
     }
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'data breakpoints'));
         }
         if (this.raw.readyForBreakpoints) {
             const response = await this.raw.setDataBreakpoints({ breakpoints: dataBreakpoints });
@@ -420,7 +420,7 @@ let DebugSession = class DebugSession {
     }
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'instruction breakpoints'));
         }
         if (this.raw.readyForBreakpoints) {
             const response = await this.raw.setInstructionBreakpoints({ breakpoints: ( instructionBreakpoints.map(ib => ib.toJSON())) });
@@ -435,7 +435,7 @@ let DebugSession = class DebugSession {
     }
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints locations'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'breakpoints locations'));
         }
         const source = this.getRawSource(uri);
         const response = await this.raw.breakpointLocations({ source, line: lineNumber });
@@ -450,20 +450,20 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", request));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", request));
         }
         return this.raw.custom(request, args);
     }
     stackTrace(threadId, startFrame, levels, token) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
         }
         const sessionToken = this.getNewCancellationToken(threadId, token);
         return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
     }
     async exceptionInfo(threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'exceptionInfo'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'exceptionInfo'));
         }
         const response = await this.raw.exceptionInfo({ threadId });
         if (response) {
@@ -478,27 +478,27 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
         }
         const token = this.getNewCancellationToken(threadId);
         return this.raw.scopes({ frameId }, token);
     }
     variables(variablesReference, threadId, filter, start, count) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
         }
         const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
         return this.raw.variables({ variablesReference, filter, start, count }, token);
     }
     evaluate(expression, frameId, context) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
         }
         return this.raw.evaluate({ expression, frameId, context });
     }
     async restartFrame(frameId, threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'restartFrame'));
         }
         await this.raw.restartFrame({ frameId }, threadId);
     }
@@ -510,87 +510,85 @@ let DebugSession = class DebugSession {
     }
     async next(threadId, granularity) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'next'));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
     }
     async stepIn(threadId, targetId, granularity) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepIn'));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
     }
     async stepOut(threadId, granularity) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepOut'));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
     }
     async stepBack(threadId, granularity) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepBack'));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
     }
     async continue(threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'continue'));
         }
         await this.raw.continue({ threadId });
     }
     async reverseContinue(threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'reverse continue'));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'pause'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'pause'));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'terminateThreads'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'terminateThreads'));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
         }
         return this.raw.setVariable({ variablesReference, name, value });
     }
     setExpression(frameId, expression, value) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'setExpression'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'setExpression'));
         }
         return this.raw.setExpression({ expression, value, frameId });
     }
     gotoTargets(source, line, column) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
         }
         return this.raw.gotoTargets({ source, line, column });
     }
     goto(threadId, targetId) {
         if (!this.raw) {
-            throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
+            throw new Error(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
         }
         return this.raw.goto({ threadId, targetId });
     }
     loadSource(resource) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'loadSource'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'loadSource')
+            )));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -605,11 +603,9 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'getLoadedSources'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'getLoadedSources')
+            )));
         }
         const response = await this.raw.loadedSources({});
         if (response && response.body && response.body.sources) {
@@ -621,11 +617,9 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'completions'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'completions')
+            )));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -637,49 +631,43 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'stepInTargets'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'stepInTargets')
+            )));
         }
         const response = await this.raw.stepInTargets({ frameId });
         return response?.body.targets;
     }
     async cancel(progressId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'cancel')))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'cancel')
+            )));
         }
         return this.raw.cancel({ progressId });
     }
     async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'disassemble')
+            )));
         }
         const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
         return response?.body?.instructions;
     }
     readMemory(memoryReference, offset, count) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'readMemory'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'readMemory')
+            )));
         }
         return this.raw.readMemory({ count, memoryReference, offset });
     }
     writeMemory(memoryReference, offset, data, allowPartial) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(
-                'noDebugAdapter',
-                "No debugger available, can not send '{0}'",
-                'disassemble'
-            )))));
+            return Promise.reject(( new Error(
+                localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'noDebugAdapter', "No debugger available, can not send '{0}'", 'disassemble')
+            )));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
@@ -783,7 +771,7 @@ let DebugSession = class DebugSession {
             return;
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
-            aria.status(( localize('debuggingStarted', "Debugging started.")));
+            aria.status(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'debuggingStarted', "Debugging started."));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -871,7 +859,7 @@ let DebugSession = class DebugSession {
             });
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            aria.status(( localize('debuggingStopped', "Debugging stopped.")));
+            aria.status(localizeWithPath('vs/workbench/contrib/debug/browser/debugSession', 'debuggingStopped', "Debugging stopped."));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }

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

@@ -15,7 +15,7 @@ async function showDebugSessionMenu(accessor, selectAndStartID) {
     const quickPick = quickInputService.createQuickPick();
     localDisposableStore.add(quickPick);
     quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', 'Search debug sessions by name'));
+    quickPick.placeholder = nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugSessionPicker', 'moveFocusedView.selectView', 'Search debug sessions by name');
     const pickItems = _getPicksAndActiveItem(quickPick.value, selectAndStartID, debugService, viewsService, commandService);
     quickPick.items = pickItems.picks;
     quickPick.activeItems = pickItems.activeItems;
@@ -59,7 +59,7 @@ function _getPicksAndActiveItem(filter, selectAndStartID, debugService, viewsSer
     if (debugConsolePicks.length) {
         debugConsolePicks.push({ type: 'separator' });
     }
-    const createDebugSessionLabel = ( nls.localize('workbench.action.debug.startDebug', 'Start a New Debug Session'));
+    const createDebugSessionLabel = nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugSessionPicker', 'workbench.action.debug.startDebug', 'Start a New Debug Session');
     debugConsolePicks.push({
         label: `$(plus) ${createDebugSessionLabel}`,
         ariaLabel: createDebugSessionLabel,
@@ -73,12 +73,7 @@ function _getSessionInfo(session) {
     let description = '';
     let ariaLabel = '';
     if (parentName) {
-        ariaLabel = ( nls.localize(
-            'workbench.action.debug.spawnFrom',
-            'Session {0} spawned from {1}',
-            label,
-            parentName
-        ));
+        ariaLabel = nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugSessionPicker', 'workbench.action.debug.spawnFrom', 'Session {0} spawned from {1}', label, parentName);
         description = parentName;
     }
     return { label, description, ariaLabel };

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

@@ -47,10 +47,10 @@ let DebugStatusContribution = class DebugStatusContribution {
             text = (manager.getLaunches().length > 1 ? `${name} (${manager.selectedConfiguration.launch.name})` : name);
         }
         return {
-            name: ( nls.localize('status.debug', "Debug")),
+            name: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugStatus', 'status.debug', "Debug"),
             text: '$(debug-alt-small) ' + text,
-            ariaLabel: ( nls.localize('debugTarget', "Debug: {0}", text)),
-            tooltip: ( nls.localize('selectAndStartDebug', "Select and start debug configuration")),
+            ariaLabel: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugStatus', 'debugTarget', "Debug: {0}", text),
+            tooltip: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugStatus', 'selectAndStartDebug', "Select and start debug configuration"),
             command: 'workbench.action.debug.selectandstart'
         };
     }

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

@@ -63,29 +63,12 @@ let DebugTaskRunner = class DebugTaskRunner {
             }
             const taskLabel = typeof taskId === 'string' ? taskId : taskId ? taskId.name : '';
             const message = errorCount > 1
-                ? ( nls.localize(
-                'preLaunchTaskErrors',
-                "Errors exist after running preLaunchTask '{0}'.",
-                taskLabel
-            ))
+                ? nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'preLaunchTaskErrors', "Errors exist after running preLaunchTask '{0}'.", taskLabel)
                 : errorCount === 1
-                    ? ( nls.localize(
-                'preLaunchTaskError',
-                "Error exists after running preLaunchTask '{0}'.",
-                taskLabel
-            ))
+                    ? nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'preLaunchTaskError', "Error exists after running preLaunchTask '{0}'.", taskLabel)
                     : taskSummary && typeof taskSummary.exitCode === 'number'
-                        ? ( nls.localize(
-                'preLaunchTaskExitCode',
-                "The preLaunchTask '{0}' terminated with exit code {1}.",
-                taskLabel,
-                taskSummary.exitCode
-            ))
-                        : ( nls.localize(
-                'preLaunchTaskTerminated',
-                "The preLaunchTask '{0}' terminated.",
-                taskLabel
-            ));
+                        ? nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'preLaunchTaskExitCode', "The preLaunchTask '{0}' terminated with exit code {1}.", taskLabel, taskSummary.exitCode)
+                        : nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'preLaunchTaskTerminated', "The preLaunchTask '{0}' terminated.", taskLabel);
             let DebugChoice;
             ( (function(DebugChoice) {
                 DebugChoice[DebugChoice["DebugAnyway"] = 1] = "DebugAnyway";
@@ -97,23 +80,20 @@ let DebugTaskRunner = class DebugTaskRunner {
                 message,
                 buttons: [
                     {
-                        label: ( nls.localize(
-                            { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] },
-                            "&&Debug Anyway"
-                        )),
+                        label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] }, "&&Debug Anyway"),
                         run: () => DebugChoice.DebugAnyway
                     },
                     {
-                        label: ( nls.localize({ key: 'showErrors', comment: ['&& denotes a mnemonic'] }, "&&Show Errors")),
+                        label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', { key: 'showErrors', comment: ['&& denotes a mnemonic'] }, "&&Show Errors"),
                         run: () => DebugChoice.ShowErrors
                     }
                 ],
                 cancelButton: {
-                    label: ( nls.localize('abort', "Abort")),
+                    label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'abort', "Abort"),
                     run: () => DebugChoice.Cancel
                 },
                 checkbox: {
-                    label: ( nls.localize('remember', "Remember my choice in user settings")),
+                    label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'remember', "Remember my choice in user settings"),
                 }
             });
             const debugAnyway = result === DebugChoice.DebugAnyway;
@@ -149,10 +129,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                     message: err.message,
                     buttons: [
                         {
-                            label: ( nls.localize(
-                                { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] },
-                                "&&Debug Anyway"
-                            )),
+                            label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', { key: 'debugAnyway', comment: ['&& denotes a mnemonic'] }, "&&Debug Anyway"),
                             run: () => DebugChoice.DebugAnyway
                         },
                         {
@@ -164,7 +141,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                         run: () => DebugChoice.Cancel
                     },
                     checkbox: {
-                        label: ( nls.localize('rememberTask', "Remember my choice for this task"))
+                        label: nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'rememberTask', "Remember my choice for this task")
                     }
                 });
                 choice = result;
@@ -184,17 +161,15 @@ let DebugTaskRunner = class DebugTaskRunner {
             return Promise.resolve(null);
         }
         if (!root) {
-            return Promise.reject(( new Error(( nls.localize(
-                'invalidTaskReference',
-                "Task '{0}' can not be referenced from a launch configuration that is in a different workspace folder.",
-                typeof taskId === 'string' ? taskId : taskId.type
-            )))));
+            return Promise.reject(( new Error(
+                nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'invalidTaskReference', "Task '{0}' can not be referenced from a launch configuration that is in a different workspace folder.", typeof taskId === 'string' ? taskId : taskId.type)
+            )));
         }
         const task = await this.taskService.getTask(root, taskId);
         if (!task) {
             const errorMessage = typeof taskId === 'string'
-                ? ( nls.localize('DebugTaskNotFoundWithTaskId', "Could not find the task '{0}'.", taskId))
-                : ( nls.localize('DebugTaskNotFound', "Could not find the specified task."));
+                ? nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'DebugTaskNotFoundWithTaskId', "Could not find the task '{0}'.", taskId)
+                : nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'DebugTaskNotFound', "Could not find the specified task.");
             return Promise.reject(createErrorWithActions(errorMessage, [( new Action(
                 DEBUG_CONFIGURE_COMMAND_ID,
                 DEBUG_CONFIGURE_LABEL,
@@ -246,16 +221,8 @@ let DebugTaskRunner = class DebugTaskRunner {
                 setTimeout(() => {
                     if (!taskStarted) {
                         const errorMessage = typeof taskId === 'string'
-                            ? ( nls.localize(
-                            'taskNotTrackedWithTaskId',
-                            "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
-                            taskId
-                        ))
-                            : ( nls.localize(
-                            'taskNotTracked',
-                            "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
-                            JSON.stringify(taskId)
-                        ));
+                            ? nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'taskNotTrackedWithTaskId', "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.", taskId)
+                            : nls.localizeWithPath('vs/workbench/contrib/debug/browser/debugTaskRunner', 'taskNotTracked', "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.", JSON.stringify(taskId));
                         e({ severity: Severity.Error, message: errorMessage });
                     }
                 }, waitTime);

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

@@ -0,0 +1,31 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/common/titleService';
+
+let DebugTitleContribution = class DebugTitleContribution {
+    constructor(debugService, hostService, titleService) {
+        this.toDispose = [];
+        const updateTitle = () => {
+            if (debugService.state === 2  && !hostService.hasFocus) {
+                titleService.updateProperties({ prefix: '🔴' });
+            }
+            else {
+                titleService.updateProperties({ prefix: '' });
+            }
+        };
+        this.toDispose.push(debugService.onDidChangeState(updateTitle));
+        this.toDispose.push(hostService.onDidChangeFocus(updateTitle));
+    }
+    dispose() {
+        dispose(this.toDispose);
+    }
+};
+DebugTitleContribution = ( __decorate([
+    ( __param(0, IDebugService)),
+    ( __param(1, IHostService)),
+    ( __param(2, ITitleService))
+], DebugTitleContribution));
+
+export { DebugTitleContribution };

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

@@ -9,7 +9,7 @@ import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
 import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import './media/debugToolBar.css.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { DropdownWithPrimaryActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
 import { createActionViewItem, createAndFillInActionBarActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
 import { MenuRegistry, MenuId, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
@@ -227,7 +227,12 @@ function createDisconnectMenuItemAction(action, disposables, accessor) {
     if (!secondary.length) {
         return undefined;
     }
-    const dropdownAction = disposables.add(( new Action('notebook.moreRunActions', ( localize('notebook.moreRunActionsLabel', "More...")), 'codicon-chevron-down', true)));
+    const dropdownAction = disposables.add(( new Action(
+        'notebook.moreRunActions',
+        localizeWithPath('vs/workbench/contrib/debug/browser/debugToolBar', 'notebook.moreRunActionsLabel', "More..."),
+        'codicon-chevron-down',
+        true
+    )));
     const item = instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, secondary, 'debug-stop-actions', contextMenuService, {});
     return item;
 }
@@ -285,8 +290,8 @@ registerDebugToolBarItem(STEP_OVER_ID, STEP_OVER_LABEL, 20, debugStepOver, undef
 registerDebugToolBarItem(STEP_INTO_ID, STEP_INTO_LABEL, 30, debugStepInto, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
 registerDebugToolBarItem(STEP_OUT_ID, STEP_OUT_LABEL, 40, debugStepOut, undefined, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
 registerDebugToolBarItem(RESTART_SESSION_ID, RESTART_LABEL, 60, debugRestart);
-registerDebugToolBarItem(STEP_BACK_ID, ( localize('stepBackDebug', "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
-registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize('reverseContinue', "Reverse")), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_BACK_ID, localizeWithPath('vs/workbench/contrib/debug/browser/debugToolBar', 'stepBackDebug', "Step Back"), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(REVERSE_CONTINUE_ID, localizeWithPath('vs/workbench/contrib/debug/browser/debugToolBar', 'reverseContinue', "Reverse"), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
 registerDebugToolBarItem(FOCUS_SESSION_ID, FOCUS_SESSION_LABEL, 100, Codicon.listTree, ( ContextKeyExpr.and(CONTEXT_MULTI_SESSION_DEBUG, ( CONTEXT_TOOLBAR_COMMAND_CENTER.negate()))));
 MenuRegistry.appendMenuItem(MenuId.DebugToolBarStop, {
     group: 'navigation',