@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/workbench/contrib/terminal/common/terminalStrings.js

@@ -1,36 +1,36 @@
 import { localize, localize2 } from '../../../../nls.js';
 const terminalStrings = {
-    terminal: ( localize(9219, "Terminal")),
-    new: ( localize(9220, "New Terminal")),
-    doNotShowAgain: ( localize(9221, 'Do Not Show Again')),
-    currentSessionCategory: ( localize(9222, 'current session')),
-    previousSessionCategory: ( localize(9223, 'previous session')),
-    typeTask: ( localize(9224, "Task")),
-    typeLocal: ( localize(9225, "Local")),
-    actionCategory: ( localize2(9226, "Terminal")),
-    focus: ( localize2(9227, "Focus Terminal")),
-    focusAndHideAccessibleBuffer: ( localize2(9228, "Focus Terminal and Hide Accessible Buffer")),
+    terminal: ( localize(9206, "Terminal")),
+    new: ( localize(9207, "New Terminal")),
+    doNotShowAgain: ( localize(9208, 'Do Not Show Again')),
+    currentSessionCategory: ( localize(9209, 'current session')),
+    previousSessionCategory: ( localize(9210, 'previous session')),
+    typeTask: ( localize(9211, "Task")),
+    typeLocal: ( localize(9212, "Local")),
+    actionCategory: ( localize2(9213, "Terminal")),
+    focus: ( localize2(9214, "Focus Terminal")),
+    focusAndHideAccessibleBuffer: ( localize2(9215, "Focus Terminal and Hide Accessible Buffer")),
     kill: {
-        ...( localize2(9229, "Kill Terminal")),
-        short: ( localize(9230, "Kill")),
+        ...( localize2(9216, "Kill Terminal")),
+        short: ( localize(9217, "Kill")),
     },
-    moveToEditor: ( localize2(9231, "Move Terminal into Editor Area")),
-    moveIntoNewWindow: ( localize2(9232, "Move Terminal into New Window")),
-    moveToTerminalPanel: ( localize2(9233, "Move Terminal into Panel")),
-    changeIcon: ( localize2(9234, "Change Icon...")),
-    changeColor: ( localize2(9235, "Change Color...")),
+    moveToEditor: ( localize2(9218, "Move Terminal into Editor Area")),
+    moveIntoNewWindow: ( localize2(9219, "Move Terminal into New Window")),
+    moveToTerminalPanel: ( localize2(9220, "Move Terminal into Panel")),
+    changeIcon: ( localize2(9221, "Change Icon...")),
+    changeColor: ( localize2(9222, "Change Color...")),
     split: {
-        ...( localize2(9236, "Split Terminal")),
-        short: ( localize(9237, "Split")),
+        ...( localize2(9223, "Split Terminal")),
+        short: ( localize(9224, "Split")),
     },
-    unsplit: ( localize2(9238, "Unsplit Terminal")),
-    rename: ( localize2(9239, "Rename...")),
-    toggleSizeToContentWidth: ( localize2(9240, "Toggle Size to Content Width")),
-    focusHover: ( localize2(9241, "Focus Hover")),
-    sendSequence: ( localize2(9242, "Send Custom Sequence To Terminal")),
-    newWithCwd: ( localize2(9243, "Create New Terminal Starting in a Custom Working Directory")),
-    renameWithArgs: ( localize2(9244, "Rename the Currently Active Terminal")),
-    scrollToPreviousCommand: ( localize2(9245, "Scroll To Previous Command")),
-    scrollToNextCommand: ( localize2(9246, "Scroll To Next Command"))
+    unsplit: ( localize2(9225, "Unsplit Terminal")),
+    rename: ( localize2(9226, "Rename...")),
+    toggleSizeToContentWidth: ( localize2(9227, "Toggle Size to Content Width")),
+    focusHover: ( localize2(9228, "Focus Hover")),
+    sendSequence: ( localize2(9229, "Send Custom Sequence To Terminal")),
+    newWithCwd: ( localize2(9230, "Create New Terminal Starting in a Custom Working Directory")),
+    renameWithArgs: ( localize2(9231, "Rename the Currently Active Terminal")),
+    scrollToPreviousCommand: ( localize2(9232, "Scroll To Previous Command")),
+    scrollToNextCommand: ( localize2(9233, "Scroll To Next Command"))
 };
 export { terminalStrings };

package/vscode/src/vs/workbench/contrib/testing/common/constants.js

@@ -25,19 +25,19 @@ var TestExplorerViewSorting;
     TestExplorerViewSorting["ByDuration"] = "duration";
 })(TestExplorerViewSorting || (TestExplorerViewSorting = {}))));
 const testStateNames = {
-    [TestResultState.Errored]: ( localize(4063, 'Errored')),
-    [TestResultState.Failed]: ( localize(4064, 'Failed')),
-    [TestResultState.Passed]: ( localize(4065, 'Passed')),
-    [TestResultState.Queued]: ( localize(4066, 'Queued')),
-    [TestResultState.Running]: ( localize(4067, 'Running')),
-    [TestResultState.Skipped]: ( localize(4068, 'Skipped')),
-    [TestResultState.Unset]: ( localize(4069, 'Not yet run')),
+    [TestResultState.Errored]: ( localize(4630, 'Errored')),
+    [TestResultState.Failed]: ( localize(4631, 'Failed')),
+    [TestResultState.Passed]: ( localize(4632, 'Passed')),
+    [TestResultState.Queued]: ( localize(4633, 'Queued')),
+    [TestResultState.Running]: ( localize(4634, 'Running')),
+    [TestResultState.Skipped]: ( localize(4635, 'Skipped')),
+    [TestResultState.Unset]: ( localize(4636, 'Not yet run')),
 };
-const labelForTestInState = (label, state) => ( localize(4070, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(4637, '{0} ({1})', stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(4071, 'Debug')),
-    [TestRunProfileBitset.Run]: ( localize(4072, 'Run')),
-    [TestRunProfileBitset.Coverage]: ( localize(4073, 'Coverage')),
+    [TestRunProfileBitset.Debug]: ( localize(4638, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localize(4639, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localize(4640, 'Coverage')),
 };
 var TestCommandId;
 ( ((function(TestCommandId) {

package/vscode/src/vs/workbench/contrib/testing/common/testResult.js

@@ -164,7 +164,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.onEndTask = this.endTaskEmitter.event;
         this.tasks = [];
         this.name = ( localize(
-            8066,
+            7625,
             'Test run at {0}',
             ( (new Date())).toLocaleString(language)
         ));
@@ -189,7 +189,9 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.doSerialize = ( (new Lazy(() => ({
             id: this.id,
             completedAt: this.completedAt,
-            tasks: ( (this.tasks.map(t => ({ id: t.id, name: t.name, ctrlId: t.ctrlId })))),
+            tasks: ( (this.tasks.map(
+                t => ({ id: t.id, name: t.name, ctrlId: t.ctrlId, hasCoverage: !!t.coverage.get() })
+            ))),
             name: this.name,
             request: this.request,
             items: ( ([...( (this.testById.values()))].map(TestResultItem.serializeWithoutMessages))),
@@ -197,7 +199,9 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.doSerializeWithMessages = ( (new Lazy(() => ({
             id: this.id,
             completedAt: this.completedAt,
-            tasks: ( (this.tasks.map(t => ({ id: t.id, name: t.name, ctrlId: t.ctrlId })))),
+            tasks: ( (this.tasks.map(
+                t => ({ id: t.id, name: t.name, ctrlId: t.ctrlId, hasCoverage: !!t.coverage.get() })
+            ))),
             name: this.name,
             request: this.request,
             items: ( ([...( (this.testById.values()))].map(TestResultItem.serialize))),
@@ -389,7 +393,7 @@ class HydratedTestResult {
         this.completedAt = serialized.completedAt;
         this.tasks = ( (serialized.tasks.map((task, i) => ({
             id: task.id,
-            name: task.name,
+            name: task.name || ( localize(7626, 'Unnamed Task')),
             ctrlId: task.ctrlId,
             running: false,
             coverage: observableValue(this, undefined),

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.d.ts

@@ -143,7 +143,7 @@ declare namespace ITestTaskState {
 }
 interface ITestRunTask {
     id: string;
-    name: string | undefined;
+    name: string;
     running: boolean;
     ctrlId: string;
 }
@@ -245,6 +245,7 @@ interface ISerializedTestResults {
         id: string;
         name: string | undefined;
         ctrlId: string;
+        hasCoverage: boolean;
     }[];
     /** Human-readable name of the test run. */
     name: string;

package/vscode/src/vs/workbench/contrib/url/browser/trustedDomains.js

@@ -11,7 +11,7 @@ const TRUSTED_DOMAINS_CONTENT_STORAGE_KEY = 'http.linkProtectionTrustedDomainsCo
 const manageTrustedDomainSettingsCommand = {
     id: 'workbench.action.manageTrustedDomain',
     description: {
-        description: ( localize2(4579, 'Manage Trusted Domains')),
+        description: ( localize2(4658, 'Manage Trusted Domains')),
         args: []
     },
     handler: async (accessor) => {
@@ -28,7 +28,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     const options = [];
     options.push({
         type: 'item',
-        label: ( localize(4580, 'Trust {0}', domainToConfigure)),
+        label: ( localize(4659, 'Trust {0}', domainToConfigure)),
         id: 'trust',
         toTrust: domainToConfigure,
         picked: true
@@ -40,7 +40,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
             const base = parsedDomainToConfigure.authority.split(':')[0];
             options.push({
                 type: 'item',
-                label: ( localize(4581, 'Trust {0} on all ports', base)),
+                label: ( localize(4660, 'Trust {0} on all ports', base)),
                 toTrust: base + ':*',
                 id: 'trust'
             });
@@ -49,20 +49,20 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     else {
         options.push({
             type: 'item',
-            label: ( localize(4582, 'Trust {0} and all its subdomains', domainEnd)),
+            label: ( localize(4661, 'Trust {0} and all its subdomains', domainEnd)),
             toTrust: topLevelDomain,
             id: 'trust'
         });
     }
     options.push({
         type: 'item',
-        label: ( localize(4583, 'Trust all domains (disables link protection)')),
+        label: ( localize(4662, 'Trust all domains (disables link protection)')),
         toTrust: '*',
         id: 'trust'
     });
     options.push({
         type: 'item',
-        label: ( localize(4584, 'Manage Trusted Domains')),
+        label: ( localize(4663, 'Manage Trusted Domains')),
         id: 'manage'
     });
     const pickedResult = await quickInputService.pick(options, { activeItem: options[0] });

package/vscode/src/vs/workbench/contrib/webview/browser/webview.contribution.js

@@ -37,7 +37,7 @@ if (CutAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CutAction.id,
-            title: ( localize(4366, "Cut")),
+            title: ( localize(4160, "Cut")),
         },
         group: '5_cutcopypaste',
         order: 1,
@@ -48,7 +48,7 @@ if (CopyAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CopyAction.id,
-            title: ( localize(4367, "Copy")),
+            title: ( localize(4161, "Copy")),
         },
         group: '5_cutcopypaste',
         order: 2,
@@ -59,7 +59,7 @@ if (PasteAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: PasteAction.id,
-            title: ( localize(4368, "Paste")),
+            title: ( localize(4162, "Paste")),
         },
         group: '5_cutcopypaste',
         order: 3,

package/vscode/src/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor.js

@@ -3,18 +3,37 @@ import { Disposable } from '../../../../base/common/lifecycle.js';
 class WebviewWindowDragMonitor extends Disposable {
     constructor(targetWindow, getWebview) {
         super();
-        this._register(addDisposableListener(targetWindow, EventType.DRAG_START, () => {
+        const onDragStart = () => {
             getWebview()?.windowDidDragStart();
-        }));
+        };
         const onDragEnd = () => {
             getWebview()?.windowDidDragEnd();
         };
+        this._register(addDisposableListener(targetWindow, EventType.DRAG_START, () => {
+            onDragStart();
+        }));
         this._register(addDisposableListener(targetWindow, EventType.DRAG_END, onDragEnd));
         this._register(addDisposableListener(targetWindow, EventType.MOUSE_MOVE, currentEvent => {
             if (currentEvent.buttons === 0) {
                 onDragEnd();
             }
         }));
+        this._register(addDisposableListener(targetWindow, EventType.DRAG, (event) => {
+            if (event.shiftKey) {
+                onDragEnd();
+            }
+            else {
+                onDragStart();
+            }
+        }));
+        this._register(addDisposableListener(targetWindow, EventType.DRAG_OVER, (event) => {
+            if (event.shiftKey) {
+                onDragEnd();
+            }
+            else {
+                onDragStart();
+            }
+        }));
     }
 }
 export { WebviewWindowDragMonitor };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -21,7 +21,7 @@ import { IWorkbenchLayoutService } from '../../../services/layout/browser/layout
 var WebviewEditor_1;
 const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( (new RawContextKey('activeWebviewPanelId', '', {
     type: 'string',
-    description: ( localize(9520, "The viewType of the currently active webview panel.")),
+    description: ( localize(9540, "The viewType of the currently active webview panel.")),
 })));
 let WebviewEditor = class WebviewEditor extends EditorPane {
     static { WebviewEditor_1 = this; }

package/vscode/src/vs/workbench/contrib/workspace/common/workspace.js

@@ -1,8 +1,8 @@
 import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 const WorkspaceTrustContext = {
-    IsEnabled: ( (new RawContextKey('isWorkspaceTrustEnabled', false, ( localize(6647, "Whether the workspace trust feature is enabled."))))),
-    IsTrusted: ( (new RawContextKey('isWorkspaceTrusted', false, ( localize(6648, "Whether the current workspace has been trusted by the user.")))))
+    IsEnabled: ( (new RawContextKey('isWorkspaceTrustEnabled', false, ( localize(6330, "Whether the workspace trust feature is enabled."))))),
+    IsTrusted: ( (new RawContextKey('isWorkspaceTrusted', false, ( localize(6331, "Whether the current workspace has been trusted by the user.")))))
 };
 const MANAGE_TRUST_COMMAND_ID = 'workbench.trust.manage';
 export { MANAGE_TRUST_COMMAND_ID, WorkspaceTrustContext };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -71,14 +71,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw ( new Error(localize(2138, 'An authentication contribution must specify an id.')));
+            throw ( new Error(localize(1669, 'An authentication contribution must specify an id.')));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(localize(2139, 'An authentication contribution must specify a label.')));
+            throw ( new Error(localize(1670, 'An authentication contribution must specify a label.')));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(localize(
-                2140,
+                1671,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             )));

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -27,7 +27,6 @@ var AuxiliaryWindowMode;
     AuxiliaryWindowMode[AuxiliaryWindowMode["Maximized"] = 0] = "Maximized";
     AuxiliaryWindowMode[AuxiliaryWindowMode["Normal"] = 1] = "Normal";
     AuxiliaryWindowMode[AuxiliaryWindowMode["Fullscreen"] = 2] = "Fullscreen";
-    AuxiliaryWindowMode[AuxiliaryWindowMode["Custom"] = 3] = "Custom";
 })(AuxiliaryWindowMode || (AuxiliaryWindowMode = {}))));
 let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     constructor(window, container, stylesHaveLoaded, configurationService, hostService, environmentService) {
@@ -92,7 +91,7 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     preventUnload(e) {
         e.preventDefault();
         e.returnValue = ( localize(
-            4141,
+            3935,
             "Changes that you made may not be saved. Please check press 'Cancel' and try again."
         ));
     }
@@ -151,7 +150,7 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         mark('code/auxiliaryWindow/willOpen');
         const targetWindow = await this.openWindow(options);
         if (!targetWindow) {
-            throw ( (new Error(localize(4142, "Unable to open a new window."))));
+            throw ( (new Error(localize(3936, "Unable to open a new window."))));
         }
         const resolvedWindowId = await this.resolveWindowId(targetWindow);
         ensureCodeWindow(targetWindow, resolvedWindowId);
@@ -215,7 +214,8 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             `top=${newWindowBounds.y}`,
             `width=${newWindowBounds.width}`,
             `height=${newWindowBounds.height}`,
-            options?.mode === AuxiliaryWindowMode.Custom ? 'titlebar=yes' : undefined,
+            options?.nativeTitlebar ? 'window-native-titlebar=yes' : undefined,
+            options?.disableFullscreen ? 'window-disable-fullscreen=yes' : undefined,
             options?.mode === AuxiliaryWindowMode.Maximized ? 'window-maximized=yes' : undefined,
             options?.mode === AuxiliaryWindowMode.Fullscreen ? 'window-fullscreen=yes' : undefined
         ]);
@@ -224,16 +224,16 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             return (await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    4143,
+                    3937,
                     "The browser interrupted the opening of a new window. Press 'Retry' to try again."
                 )),
                 detail: ( localize(
-                    4144,
+                    3938,
                     "To avoid this problem in the future, please ensure to allow popups for this website."
                 )),
                 buttons: [
                     {
-                        label: ( localize(4145, "&&Retry")),
+                        label: ( localize(3939, "&&Retry")),
                         run: () => this.openWindow(options)
                     }
                 ],

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolver.js

@@ -1,3 +1,4 @@
+import { ErrorNoTelemetry } from '../../../../base/common/errors.js';
 var VariableKind;
 ( (function(VariableKind) {
     VariableKind["Unknown"] = "unknown";
@@ -27,7 +28,7 @@ var VariableKind;
     VariableKind["PathSeparator"] = "pathSeparator";
     VariableKind["PathSeparatorAlias"] = "/";
 })(VariableKind || (VariableKind = {})));
-class VariableError extends Error {
+class VariableError extends ErrorNoTelemetry {
     constructor(variable, message) {
         super(message);
         this.variable = variable;

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverSchema.js

@@ -1,17 +1,17 @@
 import { localize } from '../../../../nls.js';
 const idDescription = ( localize(
-    10501,
+    10549,
     "The input's id is used to associate an input with a variable of the form ${input:id}."
 ));
-const typeDescription = ( localize(10502, "The type of user input prompt to use."));
-const descriptionDescription = ( localize(10503, "The description is shown when the user is prompted for input."));
-const defaultDescription = ( localize(10504, "The default value for the input."));
+const typeDescription = ( localize(10550, "The type of user input prompt to use."));
+const descriptionDescription = ( localize(10551, "The description is shown when the user is prompted for input."));
+const defaultDescription = ( localize(10552, "The default value for the input."));
 const inputsSchema = {
     definitions: {
         inputs: {
             type: 'array',
             description: ( localize(
-                10505,
+                10553,
                 'User inputs. Used for defining user input prompts, such as free string input or a choice from several options.'
             )),
             items: {
@@ -31,7 +31,7 @@ const inputsSchema = {
                                 enum: ['promptString'],
                                 enumDescriptions: [
                                     ( localize(
-                                        10506,
+                                        10554,
                                         "The 'promptString' type opens an input box to ask the user for input."
                                     )),
                                 ]
@@ -47,7 +47,7 @@ const inputsSchema = {
                             password: {
                                 type: 'boolean',
                                 description: ( localize(
-                                    10507,
+                                    10555,
                                     "Controls if a password input is shown. Password input hides the typed text."
                                 )),
                             },
@@ -67,7 +67,7 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['pickString'],
                                 enumDescriptions: [
-                                    ( localize(10508, "The 'pickString' type shows a selection list.")),
+                                    ( localize(10556, "The 'pickString' type shows a selection list.")),
                                 ]
                             },
                             description: {
@@ -80,7 +80,7 @@ const inputsSchema = {
                             },
                             options: {
                                 type: 'array',
-                                description: ( localize(10509, "An array of strings that defines the options for a quick pick.")),
+                                description: ( localize(10557, "An array of strings that defines the options for a quick pick.")),
                                 items: {
                                     oneOf: [
                                         {
@@ -93,11 +93,11 @@ const inputsSchema = {
                                             properties: {
                                                 label: {
                                                     type: 'string',
-                                                    description: ( localize(10510, "Label for the option."))
+                                                    description: ( localize(10558, "Label for the option."))
                                                 },
                                                 value: {
                                                     type: 'string',
-                                                    description: ( localize(10511, "Value for the option."))
+                                                    description: ( localize(10559, "Value for the option."))
                                                 }
                                             }
                                         }
@@ -120,26 +120,26 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['command'],
                                 enumDescriptions: [
-                                    ( localize(10512, "The 'command' type executes a command.")),
+                                    ( localize(10560, "The 'command' type executes a command.")),
                                 ]
                             },
                             command: {
                                 type: 'string',
-                                description: ( localize(10513, "The command to execute for this input variable."))
+                                description: ( localize(10561, "The command to execute for this input variable."))
                             },
                             args: {
                                 oneOf: [
                                     {
                                         type: 'object',
-                                        description: ( localize(10514, "Optional arguments passed to the command."))
+                                        description: ( localize(10562, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'array',
-                                        description: ( localize(10514, "Optional arguments passed to the command."))
+                                        description: ( localize(10562, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'string',
-                                        description: ( localize(10514, "Optional arguments passed to the command."))
+                                        description: ( localize(10562, "Optional arguments passed to the command."))
                                     }
                                 ]
                             }

package/vscode/src/vs/workbench/services/configurationResolver/common/configurationResolverUtils.js

@@ -3,7 +3,7 @@ function applyDeprecatedVariableMessage(schema) {
     schema.pattern = schema.pattern || '^(?!.*\\$\\{(env|config|command)\\.)';
     schema.patternErrorMessage = schema.patternErrorMessage ||
         ( localize(
-         10500,
+         10548,
          "'env.', 'config.' and 'command.' are deprecated, use 'env:', 'config:' and 'command:' instead."
         ));
 }

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -135,7 +135,7 @@ class AbstractVariableResolverService {
             }
             throw ( new VariableError(
                 variableKind,
-                localize(4048, "Variable {0} can not be resolved. Please open an editor.", match)
+                localize(4615, "Variable {0} can not be resolved. Please open an editor.", match)
             ));
         };
         const getFolderPathForFile = (variableKind) => {
@@ -147,7 +147,7 @@ class AbstractVariableResolverService {
                 }
             }
             throw ( new VariableError(variableKind, localize(
-                4049,
+                4616,
                 "Variable {0}: can not find workspace folder of '{1}'.",
                 match,
                 basename(filePath)
@@ -160,7 +160,7 @@ class AbstractVariableResolverService {
                     return folder;
                 }
                 throw ( new VariableError(variableKind, localize(
-                    4050,
+                    4617,
                     "Variable {0} can not be resolved. No such folder '{1}'.",
                     match,
                     argument
@@ -171,14 +171,14 @@ class AbstractVariableResolverService {
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
                 throw ( new VariableError(variableKind, localize(
-                    4051,
+                    4618,
                     "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
                     match
                 )));
             }
             throw ( new VariableError(
                 variableKind,
-                localize(4052, "Variable {0} can not be resolved. Please open a folder.", match)
+                localize(4619, "Variable {0} can not be resolved. Please open a folder.", match)
             ));
         };
         switch (variable) {
@@ -193,7 +193,7 @@ class AbstractVariableResolverService {
                     return '';
                 }
                 throw ( new VariableError(VariableKind.Env, localize(
-                    4053,
+                    4620,
                     "Variable {0} can not be resolved because no environment variable name is given.",
                     match
                 )));
@@ -202,7 +202,7 @@ class AbstractVariableResolverService {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
                         throw ( new VariableError(VariableKind.Config, localize(
-                            4054,
+                            4621,
                             "Variable {0} can not be resolved because setting '{1}' not found.",
                             match,
                             argument
@@ -210,7 +210,7 @@ class AbstractVariableResolverService {
                     }
                     if (isObject(config)) {
                         throw ( new VariableError(VariableKind.Config, localize(
-                            4055,
+                            4622,
                             "Variable {0} can not be resolved because '{1}' is a structured value.",
                             match,
                             argument
@@ -219,7 +219,7 @@ class AbstractVariableResolverService {
                     return config;
                 }
                 throw ( new VariableError(VariableKind.Config, localize(
-                    4056,
+                    4623,
                     "Variable {0} can not be resolved because no settings name is given.",
                     match
                 )));
@@ -232,7 +232,7 @@ class AbstractVariableResolverService {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
                         throw ( new VariableError(VariableKind.ExtensionInstallFolder, localize(
-                            4057,
+                            4624,
                             "Variable {0} can not be resolved because the extension {1} is not installed.",
                             match,
                             argument
@@ -241,7 +241,7 @@ class AbstractVariableResolverService {
                     return this.fsPath(ext.extensionLocation);
                 }
                 throw ( new VariableError(VariableKind.ExtensionInstallFolder, localize(
-                    4058,
+                    4625,
                     "Variable {0} can not be resolved because no extension name is given.",
                     match
                 )));
@@ -260,7 +260,7 @@ class AbstractVariableResolverService {
                             return environment.userHome;
                         }
                         throw ( new VariableError(VariableKind.UserHome, localize(
-                            4059,
+                            4626,
                             "Variable {0} can not be resolved. UserHome path is not defined",
                             match
                         )));
@@ -271,7 +271,7 @@ class AbstractVariableResolverService {
                             return lineNumber;
                         }
                         throw ( new VariableError(VariableKind.LineNumber, localize(
-                            4060,
+                            4627,
                             "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
                             match
                         )));
@@ -282,7 +282,7 @@ class AbstractVariableResolverService {
                             return selectedText;
                         }
                         throw ( new VariableError(VariableKind.SelectedText, localize(
-                            4061,
+                            4628,
                             "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
                             match
                         )));
@@ -354,7 +354,7 @@ class AbstractVariableResolverService {
                 return v;
             }
             throw ( new VariableError(variableKind, localize(
-                4062,
+                4629,
                 "Variable {0} can not be resolved because the command has no value.",
                 match
             )));