@codingame/monaco-vscode-debug-service-override 37.2.0 → 37.3.1

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

@@ -27,14 +27,14 @@ import { IDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/
 import { DEBUG_START_COMMAND_ID, DEBUG_CONFIGURE_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/browser/debugCommands';
 
 const debugStartLanguageKey = "debugStartLanguage";
-const CONTEXT_DEBUG_START_LANGUAGE = ( new RawContextKey(debugStartLanguageKey, undefined));
-const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = ( new RawContextKey("debuggerInterestedInActiveEditor", false));
+const CONTEXT_DEBUG_START_LANGUAGE = new RawContextKey(debugStartLanguageKey, undefined);
+const CONTEXT_DEBUGGER_INTERESTED_IN_ACTIVE_EDITOR = new RawContextKey("debuggerInterestedInActiveEditor", false);
 let WelcomeView = class WelcomeView extends ViewPane {
     static {
         this.ID = "workbench.debug.welcome";
     }
     static {
-        this.LABEL = ( localize2(11921, "Run"));
+        this.LABEL = ( localize2(14046, "Run"));
     }
     constructor(
         options,
@@ -121,7 +121,7 @@ WelcomeView = ( __decorate([( __param(1, IThemeService)), ( __param(2, IKeybindi
 const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        11922,
+        14047,
         "[Open a file](command:{0}) which can be debugged or run.",
         OpenFileAction.ID
     )),
@@ -130,14 +130,14 @@ viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
 });
 let debugKeybindingLabel = "";
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
-    content: `[${( localize(11923, "Run and Debug"))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
+    content: `[${( localize(14048, "Run and Debug"))}${debugKeybindingLabel}](command:${DEBUG_START_COMMAND_ID})`,
     when: CONTEXT_DEBUGGERS_AVAILABLE,
     group: ViewContentGroups.Debug,
     order: 1
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        11924,
+        14049,
         "To customize Run and Debug [create a launch.json file]({0}).",
         `${( createCommandUri(DEBUG_CONFIGURE_COMMAND_ID, {
         addNew: true
@@ -148,7 +148,7 @@ viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        11925,
+        14050,
         "To customize Run and Debug, [open a folder]({0}) and create a launch.json file.",
         (createCommandUri(OpenFolderAction.ID).toString())
     )),
@@ -157,7 +157,7 @@ viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
 });
 viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localize(
-        11926,
+        14051,
         "All debug extensions are disabled. Enable a debug extension or install a new one from the Marketplace."
     )),
     when: ( CONTEXT_DEBUG_EXTENSION_AVAILABLE.toNegated()),

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

@@ -63,12 +63,12 @@ let DebugContentProvider = class DebugContentProvider extends Disposable {
             session = this.debugService.getViewModel().focusedSession;
         }
         if (!session) {
-            return Promise.reject(( new ErrorNoTelemetry(( localize(11993, "Unable to resolve the resource without a debug session")))));
+            return Promise.reject(( new ErrorNoTelemetry(( localize(14118, "Unable to resolve the resource without a debug session")))));
         }
         const createErrModel = errMsg => {
             this.debugService.sourceIsNotAvailable(resource);
             const languageSelection = this.languageService.createById(PLAINTEXT_LANGUAGE_ID);
-            const message = errMsg ? ( localize(11994, "Could not load source '{0}': {1}.", resource.path, errMsg)) : ( localize(11995, "Could not load source '{0}'.", resource.path));
+            const message = errMsg ? ( localize(14119, "Could not load source '{0}': {1}.", resource.path, errMsg)) : ( localize(14120, "Could not load source '{0}'.", resource.path));
             return this.modelService.createModel(message, languageSelection, resource);
         };
         return session.loadSource(resource).then(response => {
@@ -85,7 +85,9 @@ let DebugContentProvider = class DebugContentProvider extends Disposable {
                     }]).then(edits => {
                         this.pendingUpdates.delete(model.id);
                         if (!myToken.token.isCancellationRequested && edits && edits.length > 0) {
-                            model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
+                            model.applyEdits(
+                                edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))
+                            );
                         }
                         return model;
                     });

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

@@ -31,19 +31,19 @@ let DebugLifecycle = class DebugLifecycle {
         let message;
         if (numSessions === 1) {
             message = ( localize(
-                11996,
+                14121,
                 "There is an active debug session, are you sure you want to stop it?"
             ));
         } else {
             message = ( localize(
-                11997,
+                14122,
                 "There are active debug sessions, are you sure you want to stop them?"
             ));
         }
         const res = await this.dialogService.confirm({
             message,
             type: "warning",
-            primaryButton: ( localize(11998, "&&Stop Debugging"))
+            primaryButton: ( localize(14123, "&&Stop Debugging"))
         });
         return !res.confirmed;
     }

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

@@ -12,7 +12,7 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "debuggers",
     defaultExtensionKind: ["workspace"],
     jsonSchema: {
-        description: ( localize(12006, "Contributes debug adapters.")),
+        description: ( localize(14131, "Contributes debug adapters.")),
         type: "array",
         defaultSnippets: [{
             body: [{
@@ -31,64 +31,64 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
             }],
             properties: {
                 type: {
-                    description: ( localize(12007, "Unique identifier for this debug adapter.")),
+                    description: ( localize(14132, "Unique identifier for this debug adapter.")),
                     type: "string"
                 },
                 label: {
-                    description: ( localize(12008, "Display name for this debug adapter.")),
+                    description: ( localize(14133, "Display name for this debug adapter.")),
                     type: "string"
                 },
                 program: {
                     description: ( localize(
-                        12009,
+                        14134,
                         "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
                     )),
                     type: "string"
                 },
                 args: {
-                    description: ( localize(12010, "Optional arguments to pass to the adapter.")),
+                    description: ( localize(14135, "Optional arguments to pass to the adapter.")),
                     type: "array"
                 },
                 runtime: {
                     description: ( localize(
-                        12011,
+                        14136,
                         "Optional runtime in case the program attribute is not an executable but requires a runtime."
                     )),
                     type: "string"
                 },
                 runtimeArgs: {
-                    description: ( localize(12012, "Optional runtime arguments.")),
+                    description: ( localize(14137, "Optional runtime arguments.")),
                     type: "array"
                 },
                 variables: {
                     description: ( localize(
-                        12013,
+                        14138,
                         "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
                     )),
                     type: "object"
                 },
                 initialConfigurations: {
-                    description: ( localize(12014, "Configurations for generating the initial 'launch.json'.")),
+                    description: ( localize(14139, "Configurations for generating the initial 'launch.json'.")),
                     type: ["array", "string"]
                 },
                 languages: {
                     description: ( localize(
-                        12015,
+                        14140,
                         "List of languages for which the debug extension could be considered the \"default debugger\"."
                     )),
                     type: "array"
                 },
                 configurationSnippets: {
-                    description: ( localize(12016, "Snippets for adding new configurations in 'launch.json'.")),
+                    description: ( localize(14141, "Snippets for adding new configurations in 'launch.json'.")),
                     type: "array"
                 },
                 configurationAttributes: {
-                    description: ( localize(12017, "JSON schema configurations for validating 'launch.json'.")),
+                    description: ( localize(14142, "JSON schema configurations for validating 'launch.json'.")),
                     type: "object"
                 },
                 when: {
                     description: ( localize(
-                        12018,
+                        14143,
                         "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."
                     )),
                     type: "string",
@@ -96,54 +96,54 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 hiddenWhen: {
                     description: ( localize(
-                        12019,
+                        14144,
                         "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
                     )),
                     type: "string",
                     default: ""
                 },
                 deprecated: {
-                    description: ( localize(12020, "Optional message to mark this debug type as being deprecated.")),
+                    description: ( localize(14145, "Optional message to mark this debug type as being deprecated.")),
                     type: "string",
                     default: ""
                 },
                 windows: {
-                    description: ( localize(12021, "Windows specific settings.")),
+                    description: ( localize(14146, "Windows specific settings.")),
                     type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(12022, "Runtime used for Windows.")),
+                            description: ( localize(14147, "Runtime used for Windows.")),
                             type: "string"
                         }
                     }
                 },
                 osx: {
-                    description: ( localize(12023, "macOS specific settings.")),
+                    description: ( localize(14148, "macOS specific settings.")),
                     type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(12024, "Runtime used for macOS.")),
+                            description: ( localize(14149, "Runtime used for macOS.")),
                             type: "string"
                         }
                     }
                 },
                 linux: {
-                    description: ( localize(12025, "Linux specific settings.")),
+                    description: ( localize(14150, "Linux specific settings.")),
                     type: "object",
                     properties: {
                         runtime: {
-                            description: ( localize(12026, "Runtime used for Linux.")),
+                            description: ( localize(14151, "Runtime used for Linux.")),
                             type: "string"
                         }
                     }
                 },
                 strings: {
-                    description: ( localize(12027, "UI strings contributed by this debug adapter.")),
+                    description: ( localize(14152, "UI strings contributed by this debug adapter.")),
                     type: "object",
                     properties: {
                         unverifiedBreakpoints: {
                             description: ( localize(
-                                12028,
+                                14153,
                                 "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."
                             )),
                             type: "string"
@@ -157,7 +157,7 @@ const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
 const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "breakpoints",
     jsonSchema: {
-        description: ( localize(12029, "Contributes breakpoints.")),
+        description: ( localize(14154, "Contributes breakpoints.")),
         type: "array",
         defaultSnippets: [{
             body: [{
@@ -174,12 +174,12 @@ const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
             }],
             properties: {
                 language: {
-                    description: ( localize(12030, "Allow breakpoints for this language.")),
+                    description: ( localize(14155, "Allow breakpoints for this language.")),
                     type: "string"
                 },
                 when: {
                     description: ( localize(
-                        12031,
+                        14156,
                         "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
                     )),
                     type: "string",
@@ -192,7 +192,7 @@ const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
 const presentationSchema = {
     type: "object",
     description: ( localize(
-        12032,
+        14157,
         "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
     )),
     properties: {
@@ -200,7 +200,7 @@ const presentationSchema = {
             type: "boolean",
             default: false,
             description: ( localize(
-                12033,
+                14158,
                 "Controls if this configuration should be shown in the configuration dropdown and the command palette."
             ))
         },
@@ -208,7 +208,7 @@ const presentationSchema = {
             type: "string",
             default: "",
             description: ( localize(
-                12034,
+                14159,
                 "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         },
@@ -216,7 +216,7 @@ const presentationSchema = {
             type: "number",
             default: 1,
             description: ( localize(
-                12035,
+                14160,
                 "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
             ))
         }
@@ -234,7 +234,7 @@ const defaultCompound = {
 const launchSchema = {
     id: launchSchemaId,
     type: "object",
-    title: ( localize(12036, "Launch")),
+    title: ( localize(14161, "Launch")),
     allowTrailingCommas: true,
     allowComments: true,
     required: [],
@@ -246,13 +246,13 @@ const launchSchema = {
     properties: {
         version: {
             type: "string",
-            description: ( localize(12037, "Version of this file format.")),
+            description: ( localize(14162, "Version of this file format.")),
             default: "0.2.0"
         },
         configurations: {
             type: "array",
             description: ( localize(
-                12038,
+                14163,
                 "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
             )),
             items: {
@@ -264,7 +264,7 @@ const launchSchema = {
         compounds: {
             type: "array",
             description: ( localize(
-                12039,
+                14164,
                 "List of compounds. Each compound references multiple configurations which will get launched together."
             )),
             items: {
@@ -274,7 +274,7 @@ const launchSchema = {
                     name: {
                         type: "string",
                         description: ( localize(
-                            12040,
+                            14165,
                             "Name of compound. Appears in the launch configuration drop down menu."
                         ))
                     },
@@ -285,7 +285,7 @@ const launchSchema = {
                         items: {
                             oneOf: [{
                                 enum: [],
-                                description: ( localize(12041, "Please use unique configuration names."))
+                                description: ( localize(14166, "Please use unique configuration names."))
                             }, {
                                 type: "object",
                                 required: ["name"],
@@ -293,19 +293,19 @@ const launchSchema = {
                                     name: {
                                         enum: [],
                                         description: ( localize(
-                                            12040,
+                                            14165,
                                             "Name of compound. Appears in the launch configuration drop down menu."
                                         ))
                                     },
                                     folder: {
                                         enum: [],
-                                        description: ( localize(12042, "Name of folder in which the compound is located."))
+                                        description: ( localize(14167, "Name of folder in which the compound is located."))
                                     }
                                 }
                             }]
                         },
                         description: ( localize(
-                            12043,
+                            14168,
                             "Names of configurations that will be started as part of this compound."
                         ))
                     },
@@ -313,14 +313,14 @@ const launchSchema = {
                         type: "boolean",
                         default: false,
                         description: ( localize(
-                            12044,
+                            14169,
                             "Controls whether manually terminating one session will stop all of the compound sessions."
                         ))
                     },
                     preLaunchTask: {
                         type: "string",
                         default: "",
-                        description: ( localize(12045, "Task to run before any of the compound configurations start."))
+                        description: ( localize(14170, "Task to run before any of the compound configurations start."))
                     }
                 },
                 default: defaultCompound
@@ -349,10 +349,10 @@ class DebuggersDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(12046, "Name")), ( localize(12047, "Type"))];
-        const rows = ( contrib.map(d => {
+        const headers = [( localize(14171, "Name")), ( localize(14172, "Type"))];
+        const rows = contrib.map(d => {
             return [d.label ?? "", d.type];
-        }));
+        });
         return {
             data: {
                 headers,
@@ -364,7 +364,7 @@ class DebuggersDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "debuggers",
-    label: ( localize(12048, "Debuggers")),
+    label: ( localize(14173, "Debuggers")),
     access: {
         canToggle: false
     },

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

@@ -59,7 +59,7 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(
+            result = JSON.parse(
                 this.storageService.get(DEBUG_BREAKPOINTS_KEY, StorageScope.WORKSPACE, "[]")
             ).map(breakpoint => {
                 breakpoint.uri = URI.revive(breakpoint.uri);
@@ -70,7 +70,7 @@ let DebugStorage = class DebugStorage extends Disposable {
                     this.logService,
                     breakpoint.id
                 ));
-            }));
+            });
         } catch (e) {
             this.logService.error("Failed to load breakpoints from storage", e);
         }
@@ -79,11 +79,11 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadFunctionBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(
+            result = JSON.parse(
                 this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE, "[]")
             ).map(fb => {
                 return ( new FunctionBreakpoint(fb, fb.id));
-            }));
+            });
         } catch (e) {
             this.logService.error("Failed to load function breakpoints from storage", e);
         }
@@ -92,11 +92,11 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadExceptionBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(
+            result = JSON.parse(
                 this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, StorageScope.WORKSPACE, "[]")
             ).map(exBreakpoint => {
                 return ( new ExceptionBreakpoint(exBreakpoint, exBreakpoint.id));
-            }));
+            });
         } catch (e) {
             this.logService.error("Failed to load exception breakpoints from storage", e);
         }
@@ -105,11 +105,11 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadDataBreakpoints() {
         let result;
         try {
-            result = ( JSON.parse(
+            result = JSON.parse(
                 this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, StorageScope.WORKSPACE, "[]")
             ).map(dbp => {
                 return ( new DataBreakpoint(dbp, dbp.id));
-            }));
+            });
         } catch (e) {
             this.logService.error("Failed to load data breakpoints from storage", e);
         }
@@ -118,11 +118,11 @@ let DebugStorage = class DebugStorage extends Disposable {
     loadWatchExpressions() {
         let result;
         try {
-            result = ( JSON.parse(
+            result = JSON.parse(
                 this.storageService.get(DEBUG_WATCH_EXPRESSIONS_KEY, StorageScope.WORKSPACE, "[]")
             ).map(watchStoredData => {
                 return ( new Expression(watchStoredData.name, watchStoredData.id));
-            }));
+            });
         } catch (e) {
             this.logService.error("Failed to load watch expressions from storage", e);
         }
@@ -146,10 +146,10 @@ let DebugStorage = class DebugStorage extends Disposable {
     }
     storeWatchExpressions(watchExpressions) {
         if (watchExpressions.length) {
-            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({
+            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(watchExpressions.map(we => ({
                 name: we.name,
                 id: we.getId()
-            })))), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+            }))), StorageScope.WORKSPACE, StorageTarget.MACHINE);
         } else {
             this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, StorageScope.WORKSPACE);
         }

package/vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.d.ts

@@ -26,8 +26,8 @@ export declare class DebugVisualizer {
     private readonly viz;
     get name(): string;
     get iconPath(): {
-        light?: import("@codingame/monaco-vscode-api/vscode/vs/base/common/uri").URI;
-        dark: import("@codingame/monaco-vscode-api/vscode/vs/base/common/uri").URI;
+        light?: import("@codingame/monaco-vscode-api/vscode/vs/sessions/sessions.web.main.internal").URI;
+        dark: import("@codingame/monaco-vscode-api/vscode/vs/sessions/sessions.web.main.internal").URI;
     } | undefined;
     get iconClass(): string | undefined;
     constructor(handle: VisualizerHandle, viz: IDebugVisualization);

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

@@ -71,7 +71,7 @@ let DebugVisualizerService = class DebugVisualizerService {
             [CONTEXT_VARIABLE_VALUE.key, variable.value],
             [CONTEXT_VARIABLE_TYPE.key, variable.type]
         ]);
-        const maybeVisualizers = await Promise.all(( this.registrations.map(async registration => {
+        const maybeVisualizers = await Promise.all(this.registrations.map(async registration => {
             if (!overlay.contextMatchesRules(registration.expr)) {
                 return;
             }
@@ -89,12 +89,12 @@ let DebugVisualizerService = class DebugVisualizerService {
                 handle,
                 result: await handle.provideDebugVisualizers(context, token)
             };
-        })));
+        }));
         const ref = {
-            object: maybeVisualizers.filter(isDefined).flatMap(v => ( v.result.map(r => ( new DebugVisualizer(v.handle, r))))),
+            object: maybeVisualizers.filter(isDefined).flatMap(v => v.result.map(r => ( new DebugVisualizer(v.handle, r)))),
             dispose: () => {
                 for (const viz of maybeVisualizers) {
-                    viz?.handle.disposeDebugVisualizers(( viz.result.map(r => r.id)));
+                    viz?.handle.disposeDebugVisualizers(viz.result.map(r => r.id));
                 }
             }
         };
@@ -138,7 +138,7 @@ let DebugVisualizerService = class DebugVisualizerService {
     async getVisualizedChildren(session, treeId, treeElementId) {
         const node = this.trees.get(treeId);
         const children = (await node?.getChildren(treeElementId)) || [];
-        return ( children.map(c => ( new VisualizedExpression(session, this, treeId, c, undefined))));
+        return children.map(c => ( new VisualizedExpression(session, this, treeId, c, undefined)));
     }
     async editTreeItem(treeId, treeItem, newValue) {
         const newItem = await this.trees.get(treeId)?.editItem?.(treeItem.id, newValue);

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

@@ -101,7 +101,7 @@ let Debugger = class Debugger {
         if (da) {
             return Promise.resolve(da);
         }
-        throw ( new Error(( localize(12050, "Cannot find debug adapter for type '{0}'.", this.type))));
+        throw ( new Error(( localize(14175, "Cannot find debug adapter for type '{0}'.", this.type))));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
@@ -170,11 +170,11 @@ let Debugger = class Debugger {
             scheme: Schemas.untitled,
             path: "1"
         }))) === "\r\n" ? "\r\n" : "\n";
-        const configs = ( JSON.stringify(initialConfigurations, null, "\t").split("\n").map(line => "\t" + line)).join(eol).trim();
-        const comment1 = ( localize(12051, "Use IntelliSense to learn about possible attributes."));
-        const comment2 = ( localize(12052, "Hover to view descriptions of existing attributes."));
+        const configs = JSON.stringify(initialConfigurations, null, "\t").split("\n").map(line => "\t" + line).join(eol).trim();
+        const comment1 = ( localize(14176, "Use IntelliSense to learn about possible attributes."));
+        const comment2 = ( localize(14177, "Hover to view descriptions of existing attributes."));
         const comment3 = ( localize(
-            12053,
+            14178,
             "For more information, visit: {0}",
             "https://go.microsoft.com/fwlink/?linkid=830387"
         ));
@@ -212,7 +212,7 @@ let Debugger = class Debugger {
         if (!this.debuggerContribution.configurationAttributes) {
             return null;
         }
-        return (Object.entries(this.debuggerContribution.configurationAttributes).map(([request, attributes]) => {
+        return Object.entries(this.debuggerContribution.configurationAttributes).map(([request, attributes]) => {
             const definitionId = `${this.type}:${request}`;
             const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
             const defaultRequired = ["name", "type", "request"];
@@ -226,22 +226,22 @@ let Debugger = class Debugger {
             properties["type"] = {
                 enum: [this.type],
                 enumDescriptions: [this.label],
-                description: ( localize(12054, "Type of configuration.")),
+                description: ( localize(14179, "Type of configuration.")),
                 pattern: "^(?!node2)",
                 deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
                 doNotSuggest: !!this.debuggerContribution.deprecated,
                 errorMessage: ( localize(
-                    12055,
+                    14180,
                     "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
                 )),
                 patternErrorMessage: ( localize(
-                    12056,
+                    14181,
                     "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
                 ))
             };
             properties["request"] = {
                 enum: [request],
-                description: ( localize(12057, "Request type of configuration. Can be \"launch\" or \"attach\"."))
+                description: ( localize(14182, "Request type of configuration. Can be \"launch\" or \"attach\"."))
             };
             for (const prop in definitions["common"].properties) {
                 properties[prop] = {
@@ -278,20 +278,20 @@ let Debugger = class Debugger {
                 ...{
                     windows: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(12058, "Windows specific launch configuration attributes."))
+                        description: ( localize(14183, "Windows specific launch configuration attributes."))
                     },
                     osx: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(12059, "OS X specific launch configuration attributes."))
+                        description: ( localize(14184, "OS X specific launch configuration attributes."))
                     },
                     linux: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( localize(12060, "Linux specific launch configuration attributes."))
+                        description: ( localize(14185, "Linux specific launch configuration attributes."))
                     }
                 }
             };
             return attributesCopy;
-        }));
+        });
     }
 };
 Debugger = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITextResourcePropertiesService)), ( __param(5, IConfigurationResolverService)), ( __param(6, IWorkbenchEnvironmentService)), ( __param(7, IDebugService)), ( __param(8, IContextKeyService)), ( __param(9, IProductService)), ( __param(10, ILogService))], Debugger));