@codingame/monaco-vscode-debug-service-override 14.0.2 → 14.0.4

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

@@ -290,7 +290,7 @@ let DebugSession = class DebugSession {
     }
     async launchOrAttach(config) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'launch or attach'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'launch or attach'))));
         }
         if (this.parentSession && this.parentSession.state === State.Inactive) {
             throw canceled();
@@ -345,7 +345,7 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'restart'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'restart'))));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -357,7 +357,7 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'breakpoints'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'breakpoints'))));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -385,7 +385,7 @@ let DebugSession = class DebugSession {
     }
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'function breakpoints'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'function breakpoints'))));
         }
         if (this.raw.readyForBreakpoints) {
             const response = await this.raw.setFunctionBreakpoints({ breakpoints: ( fbpts.map(bp => bp.toDAP())) });
@@ -400,7 +400,7 @@ let DebugSession = class DebugSession {
     }
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'exception breakpoints'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'exception breakpoints'))));
         }
         if (this.raw.readyForBreakpoints) {
             const args = this.capabilities.supportsExceptionFilterOptions ? {
@@ -424,7 +424,7 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw ( new Error(( localize(5524, "Session does not support breakpoints with bytes"))));
+            throw ( new Error(( localize(5525, "Session does not support breakpoints with bytes"))));
         }
         return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
     }
@@ -433,17 +433,17 @@ let DebugSession = class DebugSession {
     }
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'data breakpoints info'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'data breakpoints info'))));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw ( new Error(( localize(5525, "Session is not ready for breakpoints"))));
+            throw ( new Error(( localize(5526, "Session is not ready for breakpoints"))));
         }
         const response = await this.raw.dataBreakpointInfo(args);
         return response?.body;
     }
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'data breakpoints'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'data breakpoints'))));
         }
         if (this.raw.readyForBreakpoints) {
             const converted = await Promise.all(( dataBreakpoints.map(async (bp) => {
@@ -474,7 +474,7 @@ let DebugSession = class DebugSession {
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
             throw ( new Error(( localize(
-                5523,
+                5524,
                 "No debugger available, can not send '{0}'",
                 'instruction breakpoints'
             ))));
@@ -492,7 +492,7 @@ let DebugSession = class DebugSession {
     }
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'breakpoints locations'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'breakpoints locations'))));
         }
         const source = this.getRawSource(uri);
         const response = await this.raw.breakpointLocations({ source, line: lineNumber });
@@ -507,20 +507,20 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", request))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'stackTrace'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'exceptionInfo'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'exceptionInfo'))));
         }
         const response = await this.raw.exceptionInfo({ threadId });
         if (response) {
@@ -535,28 +535,28 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'scopes'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'variables'))));
+            throw ( new Error(( localize(5524, "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, location) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'evaluate'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'evaluate'))));
         }
         return this.raw.evaluate({ expression, frameId, context, line: location?.line, column: location?.column, source: location?.source });
     }
     async restartFrame(frameId, threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'restartFrame'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'restartFrame'))));
         }
         await this.raw.restartFrame({ frameId }, threadId);
     }
@@ -569,7 +569,7 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'next'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'next'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
@@ -577,7 +577,7 @@ let DebugSession = class DebugSession {
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'stepIn'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'stepIn'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
@@ -585,7 +585,7 @@ let DebugSession = class DebugSession {
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'stepOut'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'stepOut'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
@@ -593,7 +593,7 @@ let DebugSession = class DebugSession {
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'stepBack'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'stepBack'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
@@ -601,56 +601,56 @@ let DebugSession = class DebugSession {
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'continue'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'continue'))));
         }
         await this.raw.continue({ threadId });
     }
     async reverseContinue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'reverse continue'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'reverse continue'))));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'pause'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'pause'))));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'terminateThreads'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'terminateThreads'))));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'setVariable'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'setExpression'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'gotoTargets'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'goto'))));
+            throw ( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'loadSource')))));
+            return Promise.reject(( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'loadSource')))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -665,7 +665,7 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'getLoadedSources')))));
+            return Promise.reject(( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'getLoadedSources')))));
         }
         const response = await this.raw.loadedSources({});
         if (response?.body && response.body.sources) {
@@ -677,7 +677,7 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'completions')))));
+            return Promise.reject(( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'completions')))));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -689,43 +689,43 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'stepInTargets')))));
+            return Promise.reject(( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'cancel')))));
+            return Promise.reject(( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'disassemble')))));
+            return Promise.reject(( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'readMemory')))));
+            return Promise.reject(( new Error(( localize(5524, "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(5523, "No debugger available, can not send '{0}'", 'disassemble')))));
+            return Promise.reject(( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'disassemble')))));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
     async resolveLocationReference(locationReference) {
         if (!this.raw) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'locations'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'locations'))));
         }
         const location = await this.raw.locations({ locationReference });
         if (!location?.body) {
-            throw ( new Error(( localize(5523, "No debugger available, can not send '{0}'", 'locations'))));
+            throw ( new Error(( localize(5524, "No debugger available, can not send '{0}'", 'locations'))));
         }
         const source = this.getSource(location.body.source);
         return { column: 1, ...location.body, source };
@@ -837,8 +837,8 @@ let DebugSession = class DebugSession {
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
             status(this.configuration.noDebug
-                ? ( localize(5526, "Started running without debugging."))
-                : ( localize(5527, "Debugging started.")));
+                ? ( localize(5527, "Started running without debugging."))
+                : ( localize(5528, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -885,7 +885,7 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localize(5528, "Debugging stopped.")));
+            status(( localize(5529, "Debugging stopped.")));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }

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

@@ -50,10 +50,10 @@ let DebugStatusContribution = class DebugStatusContribution {
             text = (manager.getLaunches().length > 1 ? `${name} (${manager.selectedConfiguration.launch.name})` : name);
         }
         return {
-            name: ( localize(5532, "Debug")),
+            name: ( localize(5533, "Debug")),
             text: '$(debug-alt-small) ' + text,
-            ariaLabel: ( localize(5533, "Debug: {0}", text)),
-            tooltip: ( localize(5534, "Select and Start Debug Configuration")),
+            ariaLabel: ( localize(5534, "Debug: {0}", text)),
+            tooltip: ( localize(5535, "Select and Start Debug Configuration")),
             command: 'workbench.action.debug.selectandstart'
         };
     }

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

@@ -30,9 +30,9 @@ var TaskRunResult;
     TaskRunResult[TaskRunResult["Success"] = 1] = "Success";
 })(TaskRunResult || (TaskRunResult = {}));
 const DEBUG_TASK_ERROR_CHOICE_KEY = 'debug.taskerrorchoice';
-const ABORT_LABEL = ( localize(5535, "Abort"));
-const DEBUG_ANYWAY_LABEL = ( localize(5536, "&&Debug Anyway"));
-const DEBUG_ANYWAY_LABEL_NO_MEMO = ( localize(5537, "Debug Anyway"));
+const ABORT_LABEL = ( localize(5536, "Abort"));
+const DEBUG_ANYWAY_LABEL = ( localize(5537, "&&Debug Anyway"));
+const DEBUG_ANYWAY_LABEL_NO_MEMO = ( localize(5538, "Debug Anyway"));
 let DebugTaskRunner = class DebugTaskRunner {
     constructor(taskService, markerService, configurationService, viewsService, dialogService, storageService, commandService, progressService) {
         this.taskService = taskService;
@@ -74,17 +74,17 @@ let DebugTaskRunner = class DebugTaskRunner {
             }
             const taskLabel = typeof taskId === 'string' ? taskId : taskId ? taskId.name : '';
             const message = errorCount > 1
-                ? ( localize(5538, "Errors exist after running preLaunchTask '{0}'.", taskLabel))
+                ? ( localize(5539, "Errors exist after running preLaunchTask '{0}'.", taskLabel))
                 : errorCount === 1
-                    ? ( localize(5539, "Error exists after running preLaunchTask '{0}'.", taskLabel))
+                    ? ( localize(5540, "Error exists after running preLaunchTask '{0}'.", taskLabel))
                     : taskSummary && typeof taskSummary.exitCode === 'number'
                         ? ( localize(
-                5540,
+                5541,
                 "The preLaunchTask '{0}' terminated with exit code {1}.",
                 taskLabel,
                 taskSummary.exitCode
             ))
-                        : ( localize(5541, "The preLaunchTask '{0}' terminated.", taskLabel));
+                        : ( localize(5542, "The preLaunchTask '{0}' terminated.", taskLabel));
             let DebugChoice;
             (function (DebugChoice) {
                 DebugChoice[DebugChoice["DebugAnyway"] = 1] = "DebugAnyway";
@@ -100,7 +100,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                         run: () => DebugChoice.DebugAnyway
                     },
                     {
-                        label: ( localize(5542, "&&Show Errors")),
+                        label: ( localize(5543, "&&Show Errors")),
                         run: () => DebugChoice.ShowErrors
                     }
                 ],
@@ -109,7 +109,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                     run: () => DebugChoice.Cancel
                 },
                 checkbox: {
-                    label: ( localize(5543, "Remember my choice in user settings")),
+                    label: ( localize(5544, "Remember my choice in user settings")),
                 }
             });
             const debugAnyway = result === DebugChoice.DebugAnyway;
@@ -145,7 +145,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                     message: err.message,
                     buttons: [
                         {
-                            label: ( localize(5536, "&&Debug Anyway")),
+                            label: ( localize(5537, "&&Debug Anyway")),
                             run: () => DebugChoice.DebugAnyway
                         },
                         {
@@ -157,7 +157,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                         run: () => DebugChoice.Cancel
                     },
                     checkbox: {
-                        label: ( localize(5544, "Remember my choice for this task"))
+                        label: ( localize(5545, "Remember my choice for this task"))
                     }
                 });
                 choice = result;
@@ -178,7 +178,7 @@ let DebugTaskRunner = class DebugTaskRunner {
         }
         if (!root) {
             return Promise.reject(( new Error(( localize(
-                5545,
+                5546,
                 "Task '{0}' can not be referenced from a launch configuration that is in a different workspace folder.",
                 typeof taskId === 'string' ? taskId : taskId.type
             )))));
@@ -186,8 +186,8 @@ let DebugTaskRunner = class DebugTaskRunner {
         const task = await this.taskService.getTask(root, taskId);
         if (!task) {
             const errorMessage = typeof taskId === 'string'
-                ? ( localize(5546, "Could not find the task '{0}'.", taskId))
-                : ( localize(5547, "Could not find the specified task."));
+                ? ( localize(5547, "Could not find the task '{0}'.", taskId))
+                : ( localize(5548, "Could not find the specified task."));
             return Promise.reject(createErrorWithActions(errorMessage, [( new Action(
                 DEBUG_CONFIGURE_COMMAND_ID,
                 DEBUG_CONFIGURE_LABEL,
@@ -245,7 +245,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                 store.add(disposableTimeout(() => {
                     if (!taskStarted) {
                         const errorMessage = ( localize(
-                            5548,
+                            5549,
                             "The task '{0}' has not exited and doesn't have a 'problemMatcher' defined. Make sure to define a problem matcher for watch tasks.",
                             typeof taskId === 'string' ? taskId : JSON.stringify(taskId)
                         ));
@@ -256,14 +256,14 @@ let DebugTaskRunner = class DebugTaskRunner {
                 if (!hideSlowPreLaunchWarning) {
                     store.add(disposableTimeout(() => {
                         const message = ( localize(
-                            5549,
+                            5550,
                             "Waiting for preLaunchTask '{0}'...",
                             task.configurationProperties.name
                         ));
                         const buttons = [DEBUG_ANYWAY_LABEL_NO_MEMO, ABORT_LABEL];
                         const canConfigure = task instanceof CustomTask || task instanceof ConfiguringTask;
                         if (canConfigure) {
-                            buttons.splice(1, 0, ( localize(5550, "Configure Task")));
+                            buttons.splice(1, 0, ( localize(5551, "Configure Task")));
                         }
                         this.progressService.withProgress({ location: ProgressLocation.Notification, title: message, buttons }, () => result.catch(() => { }), (choice) => {
                             if (choice === undefined) ;

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

@@ -306,7 +306,7 @@ function createDisconnectMenuItemAction(action, disposables, accessor, options)
     if (!secondary.length) {
         return undefined;
     }
-    const dropdownAction = disposables.add(( new Action('notebook.moreRunActions', ( localize(5551, "More...")), 'codicon-chevron-down', true)));
+    const dropdownAction = disposables.add(( new Action('notebook.moreRunActions', ( localize(5552, "More...")), 'codicon-chevron-down', true)));
     const item = instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, secondary, 'debug-stop-actions', options);
     return item;
 }
@@ -364,8 +364,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(5552, "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
-registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize(5553, "Reverse")), 55, debugReverseContinue, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(STEP_BACK_ID, ( localize(5553, "Step Back")), 50, debugStepBack, CONTEXT_STEP_BACK_SUPPORTED, ( CONTEXT_DEBUG_STATE.isEqualTo('stopped')));
+registerDebugToolBarItem(REVERSE_CONTINUE_ID, ( localize(5554, "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',

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

@@ -169,10 +169,10 @@ registerAction2(class extends Action2 {
             title: {
                 value: DEBUG_CONFIGURE_LABEL,
                 original: 'Open \'launch.json\'',
-                mnemonicTitle: ( localize(5554, "Open &&Configurations"))
+                mnemonicTitle: ( localize(5555, "Open &&Configurations"))
             },
             metadata: {
-                description: ( localize2(5555, 'Opens the file used to configure how your program is debugged'))
+                description: ( localize2(5556, 'Opens the file used to configure how your program is debugged'))
             },
             f1: true,
             icon: debugConfigure,
@@ -212,7 +212,7 @@ registerAction2(class extends Action2 {
                 const picked = await quickInputService.pick(picks, {
                     activeItem: picks[0],
                     placeHolder: ( localize(
-                        5556,
+                        5557,
                         "Select a workspace folder to create a launch.json file in or add it to the workspace config file"
                     ))
                 });
@@ -236,7 +236,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'debug.toggleReplIgnoreFocus',
-            title: ( localize(5557, "Debug Console")),
+            title: ( localize(5558, "Debug Console")),
             toggled: ( ContextKeyExpr.has(`view.${REPL_VIEW_ID}.visible`)),
             menu: [{
                     id: ViewsSubMenu,
@@ -261,7 +261,7 @@ MenuRegistry.appendMenuItem(MenuId.ViewContainerTitle, {
     order: 10,
     command: {
         id: SELECT_AND_START_ID,
-        title: ( localize(5558, "Start Additional Session")),
+        title: ( localize(5559, "Start Additional Session")),
     }
 });
 

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

@@ -57,7 +57,7 @@ const disassemblyNotAvailable = {
     address: 0n,
     instruction: {
         address: '-1',
-        instruction: ( localize(5559, "Disassembly not available."))
+        instruction: ( localize(5560, "Disassembly not available."))
     },
 };
 let DisassemblyView = class DisassemblyView extends EditorPane {
@@ -169,7 +169,7 @@ let DisassemblyView = class DisassemblyView extends EditorPane {
                 project(row) { return row; }
             },
             {
-                label: ( localize(5560, "instructions")),
+                label: ( localize(5561, "instructions")),
                 tooltip: '',
                 weight: 0.3,
                 templateId: InstructionRenderer.TEMPLATE_ID,
@@ -704,7 +704,7 @@ let InstructionRenderer = class InstructionRenderer extends Disposable {
             };
             this.editorService.openEditor({
                 resource: sourceURI,
-                description: ( localize(5561, "from disassembly")),
+                description: ( localize(5562, "from disassembly")),
                 options: {
                     preserveFocus: false,
                     selection: selection,
@@ -739,18 +739,18 @@ InstructionRenderer = InstructionRenderer_1 = ( __decorate([
 ], InstructionRenderer));
 class AccessibilityProvider {
     getWidgetAriaLabel() {
-        return localize(5562, "Disassembly View");
+        return localize(5563, "Disassembly View");
     }
     getAriaLabel(element) {
         let label = '';
         const instruction = element.instruction;
         if (instruction.address !== '-1') {
-            label += `${( localize(5563, "Address"))}: ${instruction.address}`;
+            label += `${( localize(5564, "Address"))}: ${instruction.address}`;
         }
         if (instruction.instructionBytes) {
-            label += `, ${( localize(5564, "Bytes"))}: ${instruction.instructionBytes}`;
+            label += `, ${( localize(5565, "Bytes"))}: ${instruction.instructionBytes}`;
         }
-        label += `, ${( localize(5565, "Instruction"))}: ${instruction.instruction}`;
+        label += `, ${( localize(5566, "Instruction"))}: ${instruction.instruction}`;
         return label;
     }
 }

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

@@ -27,8 +27,8 @@ import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actio
 import { widgetClose } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
 
 const $ = $$1;
-const debugExceptionWidgetBorder = registerColor('debugExceptionWidget.border', '#a31515', ( localize(5566, 'Exception widget border color.')));
-const debugExceptionWidgetBackground = registerColor('debugExceptionWidget.background', { dark: '#420b0d', light: '#f1dfde', hcDark: '#420b0d', hcLight: '#f1dfde' }, ( localize(5567, 'Exception widget background color.')));
+const debugExceptionWidgetBorder = registerColor('debugExceptionWidget.border', '#a31515', ( localize(5567, 'Exception widget border color.')));
+const debugExceptionWidgetBackground = registerColor('debugExceptionWidget.background', { dark: '#420b0d', light: '#f1dfde', hcDark: '#420b0d', hcLight: '#f1dfde' }, ( localize(5568, 'Exception widget background color.')));
 let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
     constructor(editor, exceptionInfo, debugSession, themeService, instantiationService) {
         super(editor, { showFrame: true, showArrow: true, isAccessible: true, frameWidth: 1, className: 'exception-widget-container' });
@@ -67,10 +67,10 @@ let ExceptionWidget = class ExceptionWidget extends ZoneWidget {
         append(title, label);
         const actions = $('.actions');
         append(title, actions);
-        label.textContent = this.exceptionInfo.id ? ( localize(5568, 'Exception has occurred: {0}', this.exceptionInfo.id)) : ( localize(5569, 'Exception has occurred.'));
+        label.textContent = this.exceptionInfo.id ? ( localize(5569, 'Exception has occurred: {0}', this.exceptionInfo.id)) : ( localize(5570, 'Exception has occurred.'));
         let ariaLabel = label.textContent;
         const actionBar = ( new ActionBar(actions));
-        actionBar.push(( new Action('editor.closeExceptionWidget', ( localize(5570, "Close")), ThemeIcon.asClassName(widgetClose), true, async () => {
+        actionBar.push(( new Action('editor.closeExceptionWidget', ( localize(5571, "Close")), ThemeIcon.asClassName(widgetClose), true, async () => {
             const contribution = this.editor.getContribution(EDITOR_CONTRIBUTION_ID);
             contribution?.closeExceptionWidget();
         })), { label: false, icon: true });