@codingame/monaco-vscode-debug-service-override 8.0.1 → 8.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-debug-service-override",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@8.0.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@8.0.3"
   }
 }

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

@@ -72,7 +72,7 @@ let AdapterManager = class AdapterManager extends Disposable {
             delta.added.forEach(added => {
                 added.value.forEach(rawAdapter => {
                     if (!rawAdapter.type || (typeof rawAdapter.type !== 'string')) {
-                        added.collector.error(( localize(5739, "Debugger 'type' can not be omitted and must be of type 'string'.")));
+                        added.collector.error(( localize(5738, "Debugger 'type' can not be omitted and must be of type 'string'.")));
                     }
                     if (rawAdapter.type !== '*') {
                         const existing = this.getDebugger(rawAdapter.type);
@@ -116,7 +116,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'name': {
                         type: 'string',
                         description: ( localize(
-                            5740,
+                            5739,
                             "Name of configuration; appears in the launch configuration dropdown menu."
                         )),
                         default: 'Launch'
@@ -124,7 +124,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                     'debugServer': {
                         type: 'number',
                         description: ( localize(
-                            5741,
+                            5740,
                             "For debug extension development only: if a port is specified VS Code tries to connect to a debug adapter running in server mode"
                         )),
                         default: 4711
@@ -135,7 +135,7 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(5742, "Task to run before debug session starts."))
+                        description: ( localize(5741, "Task to run before debug session starts."))
                     },
                     'postDebugTask': {
                         anyOf: [taskSchema, {
@@ -143,14 +143,14 @@ let AdapterManager = class AdapterManager extends Disposable {
                             }],
                         default: '',
                         defaultSnippets: [{ body: { task: '', type: '' } }],
-                        description: ( localize(5743, "Task to run after debug session ends."))
+                        description: ( localize(5742, "Task to run after debug session ends."))
                     },
                     'presentation': presentationSchema,
                     'internalConsoleOptions': INTERNAL_CONSOLE_OPTIONS_SCHEMA,
                     'suppressMultipleSessionWarning': {
                         type: 'boolean',
                         description: ( localize(
-                            5744,
+                            5743,
                             "Disable the warning when trying to start the same debug configuration more than once."
                         )),
                         default: true
@@ -306,11 +306,11 @@ let AdapterManager = class AdapterManager extends Disposable {
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    5745,
+                    5744,
                     "You don't have an extension for debugging {0}. Should we find a {0} extension in the Marketplace?",
                     languageLabel
                 )),
-                primaryButton: ( localize(5746, "&&Find {0} extension", languageLabel))
+                primaryButton: ( localize(5745, "&&Find {0} extension", languageLabel))
             });
             if (confirmed) {
                 await this.commandService.executeCommand('debug.installAdditionalDebuggers', languageLabel);
@@ -336,7 +336,7 @@ let AdapterManager = class AdapterManager extends Disposable {
         });
         const picks = [];
         if (suggestedCandidates.length > 0) {
-            picks.push({ type: 'separator', label: ( localize(5747, "Suggested")) }, ...( (suggestedCandidates.map(c => ({ label: c.label, debugger: c })))));
+            picks.push({ type: 'separator', label: ( localize(5746, "Suggested")) }, ...( (suggestedCandidates.map(c => ({ label: c.label, debugger: c })))));
         }
         if (otherCandidates.length > 0) {
             if (picks.length > 0) {
@@ -344,8 +344,8 @@ let AdapterManager = class AdapterManager extends Disposable {
             }
             picks.push(...( (otherCandidates.map(c => ({ label: c.label, debugger: c })))));
         }
-        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localize(5748, "Install an extension for {0}...", languageLabel)) : ( localize(5749, "Install extension...")) });
-        const placeHolder = ( localize(5750, "Select debugger"));
+        picks.push({ type: 'separator', label: '' }, { label: languageLabel ? ( localize(5747, "Install an extension for {0}...", languageLabel)) : ( localize(5748, "Install extension...")) });
+        const placeHolder = ( localize(5749, "Select debugger"));
         return this.quickInputService.pick(picks, { activeItem: picks[0], placeHolder })
             .then(picked => {
             if (picked && picked.debugger) {

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

@@ -191,7 +191,7 @@ let ConfigurationManager = class ConfigurationManager {
                                     config,
                                     buttons: [{
                                             iconClass: ThemeIcon.asClassName(debugConfigure),
-                                            tooltip: ( localize(5785, "Edit Debug Configuration in launch.json"))
+                                            tooltip: ( localize(5784, "Edit Debug Configuration in launch.json"))
                                         }],
                                     launch
                                 }))))));
@@ -200,7 +200,7 @@ let ConfigurationManager = class ConfigurationManager {
                         const disposables = ( (new DisposableStore()));
                         const input = disposables.add(this.quickInputService.createQuickPick());
                         input.busy = true;
-                        input.placeholder = ( localize(5786, "Select Launch Configuration"));
+                        input.placeholder = ( localize(5785, "Select Launch Configuration"));
                         const chosenPromise = ( (new Promise(resolve => {
                             disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
                             disposables.add(input.onDidTriggerItemButton(async (context) => {
@@ -522,7 +522,7 @@ let Launch = class Launch extends AbstractLaunch {
             }
             catch (error) {
                 throw ( (new Error(localize(
-                    5787,
+                    5786,
                     "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).",
                     error.message
                 ))));
@@ -579,7 +579,7 @@ let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
         return this.contextService.getWorkspace().configuration;
     }
     get name() {
-        return ( localize(5788, "workspace"));
+        return ( localize(5787, "workspace"));
     }
     getConfig() {
         return this.configurationService.inspect('launch').workspaceValue;
@@ -623,7 +623,7 @@ let UserLaunch = class UserLaunch extends AbstractLaunch {
         return this.preferencesService.userSettingsResource;
     }
     get name() {
-        return ( localize(5789, "user settings"));
+        return ( localize(5788, "user settings"));
     }
     get hidden() {
         return true;

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

@@ -138,7 +138,7 @@ let DebugService = class DebugService {
             if (numberOfSessions > 0) {
                 const viewContainer = this.viewDescriptorService.getViewContainerByViewId(CALLSTACK_VIEW_ID);
                 if (viewContainer) {
-                    this.activity = this.activityService.showViewContainerActivity(viewContainer.id, { badge: ( (new NumberBadge(numberOfSessions, n => n === 1 ? ( localize(2558, "1 active session")) : ( localize(2559, "{0} active sessions", n))))) });
+                    this.activity = this.activityService.showViewContainerActivity(viewContainer.id, { badge: ( (new NumberBadge(numberOfSessions, n => n === 1 ? ( localize(2554, "1 active session")) : ( localize(2555, "{0} active sessions", n))))) });
                 }
             }
         }));
@@ -160,7 +160,7 @@ let DebugService = class DebugService {
             }
         }));
         this.disposables.add(extensionService.onWillStop(evt => {
-            evt.veto(this.model.getSessions().length > 0, ( localize(2560, 'A debug session is still running.')));
+            evt.veto(this.model.getSessions().length > 0, ( localize(2556, 'A debug session is still running.')));
         }));
         this.initContextKeys(contextKeyService);
     }
@@ -269,8 +269,8 @@ let DebugService = class DebugService {
         }
     }
     async startDebugging(launch, configOrName, options, saveBeforeStart = !options?.parentSession) {
-        const message = options && options.noDebug ? ( localize(2561, "Running executes build tasks and program code from your workspace.")) : ( localize(
-            2562,
+        const message = options && options.noDebug ? ( localize(2557, "Running executes build tasks and program code from your workspace.")) : ( localize(
+            2558,
             "Debugging executes build tasks and program code from your workspace."
         ));
         const trust = await this.workspaceTrustRequestService.requestWorkspaceTrust({ message });
@@ -301,7 +301,7 @@ let DebugService = class DebugService {
             if (compound) {
                 if (!compound.configurations) {
                     throw ( (new Error(localize(
-                        2563,
+                        2559,
                         "Compound must have \"configurations\" attribute set in order to start multiple configurations."
                     ))));
                 }
@@ -331,9 +331,9 @@ let DebugService = class DebugService {
                         }
                         else {
                             throw ( (new Error(
-                                launchesContainingName.length === 0 ? localize(2564, "Could not find launch configuration '{0}' in the workspace.", name)
+                                launchesContainingName.length === 0 ? localize(2560, "Could not find launch configuration '{0}' in the workspace.", name)
                                     : localize(
-                                    2565,
+                                    2561,
                                     "There are multiple launch configurations '{0}' in the workspace. Use folder name to qualify the configuration.",
                                     name
                                 )
@@ -347,7 +347,7 @@ let DebugService = class DebugService {
                         }
                         else {
                             throw ( (new Error(localize(
-                                2566,
+                                2562,
                                 "Can not find folder with name '{0}' for configuration '{1}' in compound '{2}'.",
                                 configData.folder,
                                 configData.name,
@@ -363,11 +363,11 @@ let DebugService = class DebugService {
             }
             if (configOrName && !config) {
                 const message = !!launch ? ( localize(
-                    2567,
+                    2563,
                     "Configuration '{0}' is missing in 'launch.json'.",
                     typeof configOrName === 'string' ? configOrName : configOrName.name
                 )) :
-                    ( localize(2568, "'launch.json' does not exist for passed workspace folder."));
+                    ( localize(2564, "'launch.json' does not exist for passed workspace folder."));
                 throw ( (new Error(message)));
             }
             const result = await this.createSession(launch, config, options);
@@ -440,23 +440,23 @@ let DebugService = class DebugService {
                     let message;
                     if (configByProviders.request !== 'attach' && configByProviders.request !== 'launch') {
                         message = configByProviders.request ? ( localize(
-                            2569,
+                            2565,
                             "Attribute '{0}' has an unsupported value '{1}' in the chosen debug configuration.",
                             'request',
                             configByProviders.request
                         ))
                             : ( localize(
-                            2570,
+                            2566,
                             "Attribute '{0}' is missing from the chosen debug configuration.",
                             'request'
                         ));
                     }
                     else {
-                        message = resolvedConfig.type ? ( localize(2571, "Configured debug type '{0}' is not supported.", resolvedConfig.type)) :
-                            ( localize(2572, "Missing property 'type' for the chosen launch configuration."));
+                        message = resolvedConfig.type ? ( localize(2567, "Configured debug type '{0}' is not supported.", resolvedConfig.type)) :
+                            ( localize(2568, "Missing property 'type' for the chosen launch configuration."));
                     }
                     const actionList = [];
-                    actionList.push(( (new Action('installAdditionalDebuggers', ( localize(2573, "Install {0} Extension", resolvedConfig.type)), undefined, true, async () => this.commandService.executeCommand('debug.installAdditionalDebuggers', resolvedConfig?.type)))));
+                    actionList.push(( (new Action('installAdditionalDebuggers', ( localize(2569, "Install {0} Extension", resolvedConfig.type)), undefined, true, async () => this.commandService.executeCommand('debug.installAdditionalDebuggers', resolvedConfig?.type)))));
                     await this.showError(message, actionList);
                     return false;
                 }
@@ -477,7 +477,7 @@ let DebugService = class DebugService {
                 }
                 else if (this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
                     await this.showError(( localize(
-                        2574,
+                        2570,
                         "The active file can not be debugged. Make sure it is saved and that you have a debug extension installed for that file type."
                     )));
                 }
@@ -496,7 +496,7 @@ let DebugService = class DebugService {
         const session = this.instantiationService.createInstance(DebugSession, sessionId, configuration, root, this.model, options);
         if (options?.startedByUser && ( (this.model.getSessions().some(s => s.getLabel() === session.getLabel()))) && configuration.resolved.suppressMultipleSessionWarning !== true) {
             const result = await this.dialogService.confirm({ message: ( localize(
-                2575,
+                2571,
                 "'{0}' is already running. Do you want to start another instance?",
                 session.getLabel()
             )) });
@@ -587,7 +587,7 @@ let DebugService = class DebugService {
             if (adapterExitEvent) {
                 if (adapterExitEvent.error) {
                     this.notificationService.error(( localize(
-                        2576,
+                        2572,
                         "Debug adapter process has terminated unexpectedly ({0})",
                         adapterExitEvent.error.message || ( (adapterExitEvent.error.toString()))
                     )));
@@ -830,7 +830,7 @@ let DebugService = class DebugService {
                         if (lineNumber >= 1 && lineNumber <= model.getLineCount()) {
                             const lineContent = control.getModel().getLineContent(lineNumber);
                             alert(( localize(
-                                2577,
+                                2573,
                                 "{0}, debugging paused {1}, {2}:{3}",
                                 lineContent,
                                 thread && thread.stoppedDetails ? `, reason ${thread.stoppedDetails.reason}` : '',
@@ -903,7 +903,7 @@ let DebugService = class DebugService {
     async addBreakpoints(uri, rawBreakpoints, ariaAnnounce = true) {
         const breakpoints = this.model.addBreakpoints(uri, rawBreakpoints);
         if (ariaAnnounce) {
-            breakpoints.forEach(bp => status(( localize(2578, "Added breakpoint, line {0}, file {1}", bp.lineNumber, uri.fsPath))));
+            breakpoints.forEach(bp => status(( localize(2574, "Added breakpoint, line {0}, file {1}", bp.lineNumber, uri.fsPath))));
         }
         this.debugStorage.storeBreakpoints(this.model);
         await this.sendBreakpoints(uri);
@@ -925,7 +925,7 @@ let DebugService = class DebugService {
         const breakpoints = this.model.getBreakpoints();
         const toRemove = breakpoints.filter(bp => !id || bp.getId() === id);
         toRemove.forEach(bp => status(( localize(
-            2579,
+            2575,
             "Removed breakpoint, line {0}, file {1}",
             bp.lineNumber,
             bp.uri.fsPath

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(5790, "No debugger available, can not send '{0}'", 'launch or attach')
+                localize(5789, "No debugger available, can not send '{0}'", 'launch or attach')
             )));
         }
         if (this.parentSession && this.parentSession.state === State.Inactive) {
@@ -346,7 +346,7 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'restart'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'restart'))));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -358,7 +358,7 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'breakpoints'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'breakpoints'))));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -387,7 +387,7 @@ let DebugSession = class DebugSession {
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'function breakpoints')
+                localize(5789, "No debugger available, can not send '{0}'", 'function breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -404,7 +404,7 @@ let DebugSession = class DebugSession {
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'exception breakpoints')
+                localize(5789, "No debugger available, can not send '{0}'", 'exception breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -429,7 +429,7 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw ( (new Error(localize(5791, "Session does not support breakpoints with bytes"))));
+            throw ( (new Error(localize(5790, "Session does not support breakpoints with bytes"))));
         }
         return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
     }
@@ -439,11 +439,11 @@ let DebugSession = class DebugSession {
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'data breakpoints info')
+                localize(5789, "No debugger available, can not send '{0}'", 'data breakpoints info')
             )));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw ( (new Error(localize(5792, "Session is not ready for breakpoints"))));
+            throw ( (new Error(localize(5791, "Session is not ready for breakpoints"))));
         }
         const response = await this.raw.dataBreakpointInfo(args);
         return response?.body;
@@ -451,7 +451,7 @@ let DebugSession = class DebugSession {
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'data breakpoints')
+                localize(5789, "No debugger available, can not send '{0}'", 'data breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -483,7 +483,7 @@ let DebugSession = class DebugSession {
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
             throw ( (new Error(localize(
-                5790,
+                5789,
                 "No debugger available, can not send '{0}'",
                 'instruction breakpoints'
             ))));
@@ -502,7 +502,7 @@ let DebugSession = class DebugSession {
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'breakpoints locations')
+                localize(5789, "No debugger available, can not send '{0}'", 'breakpoints locations')
             )));
         }
         const source = this.getRawSource(uri);
@@ -518,13 +518,13 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", request))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'stackTrace'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stackTrace'))));
         }
         const sessionToken = this.getNewCancellationToken(threadId, token);
         return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
@@ -532,7 +532,7 @@ let DebugSession = class DebugSession {
     async exceptionInfo(threadId) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'exceptionInfo')
+                localize(5789, "No debugger available, can not send '{0}'", 'exceptionInfo')
             )));
         }
         const response = await this.raw.exceptionInfo({ threadId });
@@ -548,21 +548,21 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'scopes'))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'variables'))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'evaluate'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'evaluate'))));
         }
         return this.raw.evaluate({ expression, frameId, context, line: location?.line, column: location?.column, source: location?.source });
     }
@@ -570,7 +570,7 @@ let DebugSession = class DebugSession {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'restartFrame')
+                localize(5789, "No debugger available, can not send '{0}'", 'restartFrame')
             )));
         }
         await this.raw.restartFrame({ frameId }, threadId);
@@ -584,7 +584,7 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'next'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'next'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
@@ -592,7 +592,7 @@ let DebugSession = class DebugSession {
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'stepIn'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepIn'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
@@ -600,7 +600,7 @@ let DebugSession = class DebugSession {
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'stepOut'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepOut'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
@@ -608,7 +608,7 @@ let DebugSession = class DebugSession {
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'stepBack'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepBack'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
@@ -616,7 +616,7 @@ let DebugSession = class DebugSession {
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'continue'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'continue'))));
         }
         await this.raw.continue({ threadId });
     }
@@ -624,54 +624,54 @@ let DebugSession = class DebugSession {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'reverse continue')
+                localize(5789, "No debugger available, can not send '{0}'", 'reverse continue')
             )));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'pause'))));
+            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'pause'))));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5790, "No debugger available, can not send '{0}'", 'terminateThreads')
+                localize(5789, "No debugger available, can not send '{0}'", 'terminateThreads')
             )));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw ( (new Error(localize(5790, "No debugger available, can not send '{0}'", 'setVariable'))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'setExpression')
+                localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'gotoTargets'))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'goto'))));
+            throw ( (new Error(localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'loadSource'))))));
+            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'loadSource'))))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -686,7 +686,7 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5790, "No debugger available, can not send '{0}'", 'getLoadedSources'))))));
+            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'getLoadedSources'))))));
         }
         const response = await this.raw.loadedSources({});
         if (response?.body && response.body.sources) {
@@ -700,7 +700,7 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5790, "No debugger available, can not send '{0}'", 'completions'))))));
+            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'completions'))))));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -712,33 +712,33 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5790, "No debugger available, can not send '{0}'", 'stepInTargets'))))));
+            return Promise.reject(( (new Error(( localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'cancel'))))));
+            return Promise.reject(( (new Error(( localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'readMemory'))))));
+            return Promise.reject(( (new Error(( localize(5789, "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(5790, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
@@ -849,8 +849,8 @@ let DebugSession = class DebugSession {
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
             status(this.configuration.noDebug
-                ? ( localize(5793, "Started running without debugging."))
-                : ( localize(5794, "Debugging started.")));
+                ? ( localize(5792, "Started running without debugging."))
+                : ( localize(5793, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -897,7 +897,7 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localize(5795, "Debugging stopped.")));
+            status(( localize(5794, "Debugging stopped.")));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }

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

@@ -70,17 +70,17 @@ let DebugTaskRunner = class DebugTaskRunner {
             }
             const taskLabel = typeof taskId === 'string' ? taskId : taskId ? taskId.name : '';
             const message = errorCount > 1
-                ? ( localize(5796, "Errors exist after running preLaunchTask '{0}'.", taskLabel))
+                ? ( localize(5795, "Errors exist after running preLaunchTask '{0}'.", taskLabel))
                 : errorCount === 1
-                    ? ( localize(5797, "Error exists after running preLaunchTask '{0}'.", taskLabel))
+                    ? ( localize(5796, "Error exists after running preLaunchTask '{0}'.", taskLabel))
                     : taskSummary && typeof taskSummary.exitCode === 'number'
                         ? ( localize(
-                5798,
+                5797,
                 "The preLaunchTask '{0}' terminated with exit code {1}.",
                 taskLabel,
                 taskSummary.exitCode
             ))
-                        : ( localize(5799, "The preLaunchTask '{0}' terminated.", taskLabel));
+                        : ( localize(5798, "The preLaunchTask '{0}' terminated.", taskLabel));
             let DebugChoice;
             ( ((function(DebugChoice) {
                 DebugChoice[DebugChoice["DebugAnyway"] = 1] = "DebugAnyway";
@@ -92,20 +92,20 @@ let DebugTaskRunner = class DebugTaskRunner {
                 message,
                 buttons: [
                     {
-                        label: ( localize(5800, "&&Debug Anyway")),
+                        label: ( localize(5799, "&&Debug Anyway")),
                         run: () => DebugChoice.DebugAnyway
                     },
                     {
-                        label: ( localize(5801, "&&Show Errors")),
+                        label: ( localize(5800, "&&Show Errors")),
                         run: () => DebugChoice.ShowErrors
                     }
                 ],
                 cancelButton: {
-                    label: ( localize(5802, "Abort")),
+                    label: ( localize(5801, "Abort")),
                     run: () => DebugChoice.Cancel
                 },
                 checkbox: {
-                    label: ( localize(5803, "Remember my choice in user settings")),
+                    label: ( localize(5802, "Remember my choice in user settings")),
                 }
             });
             const debugAnyway = result === DebugChoice.DebugAnyway;
@@ -141,7 +141,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                     message: err.message,
                     buttons: [
                         {
-                            label: ( localize(5800, "&&Debug Anyway")),
+                            label: ( localize(5799, "&&Debug Anyway")),
                             run: () => DebugChoice.DebugAnyway
                         },
                         {
@@ -153,7 +153,7 @@ let DebugTaskRunner = class DebugTaskRunner {
                         run: () => DebugChoice.Cancel
                     },
                     checkbox: {
-                        label: ( localize(5804, "Remember my choice for this task"))
+                        label: ( localize(5803, "Remember my choice for this task"))
                     }
                 });
                 choice = result;
@@ -174,7 +174,7 @@ let DebugTaskRunner = class DebugTaskRunner {
         }
         if (!root) {
             return Promise.reject(( (new Error(( localize(
-                5805,
+                5804,
                 "Task '{0}' can not be referenced from a launch configuration that is in a different workspace folder.",
                 typeof taskId === 'string' ? taskId : taskId.type
             ))))));
@@ -182,8 +182,8 @@ let DebugTaskRunner = class DebugTaskRunner {
         const task = await this.taskService.getTask(root, taskId);
         if (!task) {
             const errorMessage = typeof taskId === 'string'
-                ? ( localize(5806, "Could not find the task '{0}'.", taskId))
-                : ( localize(5807, "Could not find the specified task."));
+                ? ( localize(5805, "Could not find the task '{0}'.", taskId))
+                : ( localize(5806, "Could not find the specified task."));
             return Promise.reject(createErrorWithActions(errorMessage, [( (new Action(
                 DEBUG_CONFIGURE_COMMAND_ID,
                 DEBUG_CONFIGURE_LABEL,
@@ -238,12 +238,12 @@ let DebugTaskRunner = class DebugTaskRunner {
                         if (!taskStarted) {
                             const errorMessage = typeof taskId === 'string'
                                 ? ( localize(
-                                5808,
+                                5807,
                                 "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
                                 taskId
                             ))
                                 : ( localize(
-                                5809,
+                                5808,
                                 "The task '{0}' cannot be tracked. Make sure to have a problem matcher defined.",
                                 JSON.stringify(taskId)
                             ));