@codingame/monaco-vscode-api 25.0.0 → 25.1.0

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

@@ -27,19 +27,19 @@ var TestExplorerViewSorting;
     TestExplorerViewSorting["ByDuration"] = "duration";
 })(TestExplorerViewSorting || (TestExplorerViewSorting = {}));
 const testStateNames = {
-    [TestResultState.Errored]: ( localize(12708, 'Errored')),
-    [TestResultState.Failed]: ( localize(12709, 'Failed')),
-    [TestResultState.Passed]: ( localize(12710, 'Passed')),
-    [TestResultState.Queued]: ( localize(12711, 'Queued')),
-    [TestResultState.Running]: ( localize(12712, 'Running')),
-    [TestResultState.Skipped]: ( localize(12713, 'Skipped')),
-    [TestResultState.Unset]: ( localize(12714, 'Not yet run')),
+    [TestResultState.Errored]: ( localize(12709, 'Errored')),
+    [TestResultState.Failed]: ( localize(12710, 'Failed')),
+    [TestResultState.Passed]: ( localize(12711, 'Passed')),
+    [TestResultState.Queued]: ( localize(12712, 'Queued')),
+    [TestResultState.Running]: ( localize(12713, 'Running')),
+    [TestResultState.Skipped]: ( localize(12714, 'Skipped')),
+    [TestResultState.Unset]: ( localize(12715, 'Not yet run')),
 };
-const labelForTestInState = (label, state) => ( localize(12715, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(12716, '{0} ({1})', stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(12716, 'Debug')),
-    [TestRunProfileBitset.Run]: ( localize(12717, 'Run')),
-    [TestRunProfileBitset.Coverage]: ( localize(12718, 'Coverage')),
+    [TestRunProfileBitset.Debug]: ( localize(12717, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localize(12718, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localize(12719, 'Coverage')),
 };
 var TestCommandId;
 (function (TestCommandId) {

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

@@ -12,7 +12,7 @@ import { ITelemetryService } from '../../../../platform/telemetry/common/telemet
 import { refreshComputedState } from './getComputedState.js';
 import { TestId } from './testId.js';
 import { statesInOrder, makeEmptyCounts, terminalStatePriorities, maxPriority } from './testingStates.js';
-import { getMarkId, TestResultState, TestItemExpandState, TestResultItem, TestMessageType } from './testTypes.js';
+import { TestResultState, getMarkId, TestItemExpandState, TestResultItem, TestMessageType } from './testTypes.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 
 const emptyRawOutput = {
@@ -160,7 +160,7 @@ let LiveTestResult = class LiveTestResult extends Disposable {
         this.onNewTask = this.newTaskEmitter.event;
         this.onEndTask = this.endTaskEmitter.event;
         this.tasks = [];
-        this.name = ( localize(12719, 'Test run at {0}', ( new Date()).toLocaleString(language)));
+        this.name = ( localize(12720, 'Test run at {0}', ( new Date()).toLocaleString(language)));
         this.counts = makeEmptyCounts();
         this.computedStateAccessor = {
             getOwnState: i => i.ownComputedState,
@@ -384,7 +384,7 @@ class HydratedTestResult {
         this.completedAt = serialized.completedAt;
         this.tasks = ( serialized.tasks.map((task, i) => ({
             id: task.id,
-            name: task.name || ( localize(12720, 'Unnamed Task')),
+            name: task.name || ( localize(12721, 'Unnamed Task')),
             ctrlId: task.ctrlId,
             running: false,
             coverage: observableValue(this, undefined),

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

@@ -46,9 +46,9 @@ var TestRunProfileBitset;
     TestRunProfileBitset[TestRunProfileBitset["SupportsContinuousRun"] = 64] = "SupportsContinuousRun";
 })(TestRunProfileBitset || (TestRunProfileBitset = {}));
 const testProfileBitset = {
-    [TestRunProfileBitset.Run]: ( localize(12723, 'Run')),
-    [TestRunProfileBitset.Debug]: ( localize(12724, 'Debug')),
-    [TestRunProfileBitset.Coverage]: ( localize(12725, 'Coverage')),
+    [TestRunProfileBitset.Run]: ( localize(12724, 'Run')),
+    [TestRunProfileBitset.Debug]: ( localize(12725, 'Debug')),
+    [TestRunProfileBitset.Coverage]: ( localize(12726, 'Coverage')),
 };
 const testRunProfileBitsetList = [
     TestRunProfileBitset.Run,

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

@@ -48,7 +48,7 @@ async function openInEditor(editorService, resource) {
 const manageTrustedDomainSettingsCommand = {
     id: 'workbench.action.manageTrustedDomain',
     description: {
-        description: ( localize2(12911, 'Manage Trusted Domains')),
+        description: ( localize2(12912, 'Manage Trusted Domains')),
         args: []
     },
     handler: async (accessor) => {
@@ -65,7 +65,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     const options = [];
     options.push({
         type: 'item',
-        label: ( localize(12912, 'Trust {0}', domainToConfigure)),
+        label: ( localize(12913, 'Trust {0}', domainToConfigure)),
         id: 'trust',
         toTrust: domainToConfigure,
         picked: true
@@ -77,7 +77,7 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
             const base = parsedDomainToConfigure.authority.split(':')[0];
             options.push({
                 type: 'item',
-                label: ( localize(12913, 'Trust {0} on all ports', base)),
+                label: ( localize(12914, 'Trust {0} on all ports', base)),
                 toTrust: base + ':*',
                 id: 'trust'
             });
@@ -86,20 +86,20 @@ async function configureOpenerTrustedDomainsHandler(trustedDomains, domainToConf
     else {
         options.push({
             type: 'item',
-            label: ( localize(12914, 'Trust {0} and all its subdomains', domainEnd)),
+            label: ( localize(12915, 'Trust {0} and all its subdomains', domainEnd)),
             toTrust: topLevelDomain,
             id: 'trust'
         });
     }
     options.push({
         type: 'item',
-        label: ( localize(12915, 'Trust all domains (disables link protection)')),
+        label: ( localize(12916, 'Trust all domains (disables link protection)')),
         toTrust: '*',
         id: 'trust'
     });
     options.push({
         type: 'item',
-        label: ( localize(12916, 'Manage Trusted Domains')),
+        label: ( localize(12917, '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

@@ -39,7 +39,7 @@ if (CutAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CutAction.id,
-            title: ( localize(13154, "Cut")),
+            title: ( localize(13155, "Cut")),
         },
         group: '5_cutcopypaste',
         order: 1,
@@ -50,7 +50,7 @@ if (CopyAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: CopyAction.id,
-            title: ( localize(13155, "Copy")),
+            title: ( localize(13156, "Copy")),
         },
         group: '5_cutcopypaste',
         order: 2,
@@ -61,7 +61,7 @@ if (PasteAction) {
     MenuRegistry.appendMenuItem(MenuId.WebviewContext, {
         command: {
             id: PasteAction.id,
-            title: ( localize(13156, "Paste")),
+            title: ( localize(13157, "Paste")),
         },
         group: '5_cutcopypaste',
         order: 3,

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

@@ -23,7 +23,7 @@ import { IWorkbenchLayoutService } from '../../../services/layout/browser/layout
 var WebviewEditor_1;
 const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey('activeWebviewPanelId', '', {
     type: 'string',
-    description: ( localize(13163, "The viewType of the currently active webview panel.")),
+    description: ( localize(13164, "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

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

package/vscode/src/vs/workbench/services/accounts/common/defaultAccount.js

@@ -348,7 +348,7 @@ let DefaultAccountManagementContribution = class DefaultAccountManagementContrib
             constructor() {
                 super({
                     id: DEFAULT_ACCOUNT_SIGN_IN_COMMAND,
-                    title: ( localize(13584, "Sign in")),
+                    title: ( localize(13585, "Sign in")),
                 });
             }
             run() {

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

@@ -44,23 +44,23 @@ const authenticationDefinitionSchema = {
     properties: {
         id: {
             type: 'string',
-            description: ( localize(13733, 'The id of the authentication provider.'))
+            description: ( localize(13734, 'The id of the authentication provider.'))
         },
         label: {
             type: 'string',
-            description: ( localize(13734, 'The human readable name of the authentication provider.')),
+            description: ( localize(13735, 'The human readable name of the authentication provider.')),
         },
         authorizationServerGlobs: {
             type: 'array',
             items: {
                 type: 'string',
                 description: ( localize(
-                    13735,
+                    13736,
                     'A list of globs that match the authorization servers that this provider supports.'
                 )),
             },
             description: ( localize(
-                13736,
+                13737,
                 'A list of globs that match the authorization servers that this provider supports.'
             ))
         }
@@ -69,7 +69,7 @@ const authenticationDefinitionSchema = {
 const authenticationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'authentication',
     jsonSchema: {
-        description: ( localize(13737, 'Contributes authentication')),
+        description: ( localize(13738, 'Contributes authentication')),
         type: 'array',
         items: authenticationDefinitionSchema
     },
@@ -134,11 +134,11 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             added.forEach(point => {
                 for (const provider of point.value) {
                     if (isFalsyOrWhitespace(provider.id)) {
-                        point.collector.error(( localize(13738, 'An authentication contribution must specify an id.')));
+                        point.collector.error(( localize(13739, 'An authentication contribution must specify an id.')));
                         continue;
                     }
                     if (isFalsyOrWhitespace(provider.label)) {
-                        point.collector.error(( localize(13739, 'An authentication contribution must specify a label.')));
+                        point.collector.error(( localize(13740, 'An authentication contribution must specify a label.')));
                         continue;
                     }
                     if (!( this.declaredProviders.some(p => p.id === provider.id))) {
@@ -147,7 +147,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                     }
                     else {
                         point.collector.error(( localize(
-                            13740,
+                            13741,
                             "This authentication id '{0}' has already been registered",
                             provider.id
                         )));
@@ -166,14 +166,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw ( new Error(( localize(13738, 'An authentication contribution must specify an id.'))));
+            throw ( new Error(( localize(13739, 'An authentication contribution must specify an id.'))));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(( localize(13739, 'An authentication contribution must specify a label.'))));
+            throw ( new Error(( localize(13740, 'An authentication contribution must specify a label.'))));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(( localize(
-                13740,
+                13741,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             ))));

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

@@ -104,7 +104,7 @@ let AuxiliaryWindow = class AuxiliaryWindow extends BaseWindow {
     preventUnload(e) {
         e.preventDefault();
         e.returnValue = ( localize(
-            13741,
+            13742,
             "Changes that you made may not be saved. Please check press 'Cancel' and try again."
         ));
     }
@@ -166,7 +166,7 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         mark('code/auxiliaryWindow/willOpen');
         const targetWindow = await this.openWindow(options);
         if (!targetWindow) {
-            throw ( new Error(( localize(13742, "Unable to open a new window."))));
+            throw ( new Error(( localize(13743, "Unable to open a new window."))));
         }
         const resolvedWindowId = await this.resolveWindowId(targetWindow);
         ensureCodeWindow(targetWindow, resolvedWindowId);
@@ -243,19 +243,19 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
             return (await this.dialogService.prompt({
                 type: Severity$1.Warning,
                 message: ( localize(
-                    13743,
+                    13744,
                     "The browser blocked opening a new window. Press 'Retry' to try again."
                 )),
                 custom: {
                     markdownDetails: [{ markdown: ( new MarkdownString(( localize(
-                        13744,
+                        13745,
                         "Please allow pop-ups for this website in your [browser settings]({0}).",
                         'https://aka.ms/allow-vscode-popup'
                     )), true)) }]
                 },
                 buttons: [
                     {
-                        label: ( localize(13745, "&&Retry")),
+                        label: ( localize(13746, "&&Retry")),
                         run: () => this.openWindow(options)
                     }
                 ],

package/vscode/src/vs/workbench/services/chat/common/chatEntitlementService.js

@@ -631,7 +631,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
         };
         const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, sessions, CancellationToken.None);
         if (!response) {
-            const retry = await this.onUnknownSignUpError(( localize(13746, "No response received.")), '[chat entitlement] sign-up: no response');
+            const retry = await this.onUnknownSignUpError(( localize(13747, "No response received.")), '[chat entitlement] sign-up: no response');
             return retry ? this.signUpFree(sessions) : { errorCode: 1 };
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
@@ -649,7 +649,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                 catch (error) {
                 }
             }
-            const retry = await this.onUnknownSignUpError(( localize(13747, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
+            const retry = await this.onUnknownSignUpError(( localize(13748, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
             return retry ? this.signUpFree(sessions) : { errorCode: response.res.statusCode };
         }
         let responseText = null;
@@ -659,7 +659,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
         catch (error) {
         }
         if (!responseText) {
-            const retry = await this.onUnknownSignUpError(( localize(13748, "Response has no contents.")), '[chat entitlement] sign-up: response has no content');
+            const retry = await this.onUnknownSignUpError(( localize(13749, "Response has no contents.")), '[chat entitlement] sign-up: response has no content');
             return retry ? this.signUpFree(sessions) : { errorCode: 2 };
         }
         let parsedResult = undefined;
@@ -668,7 +668,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             this.logService.trace(`[chat entitlement] sign-up: response is ${responseText}`);
         }
         catch (err) {
-            const retry = await this.onUnknownSignUpError(( localize(13749, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
+            const retry = await this.onUnknownSignUpError(( localize(13750, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
             return retry ? this.signUpFree(sessions) : { errorCode: 3 };
         }
         this.update({ entitlement: ChatEntitlement.Free });
@@ -680,11 +680,11 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13750,
+                    13751,
                     "An error occurred while signing up for the GitHub Copilot Free plan. Would you like to try again?"
                 )),
                 detail,
-                primaryButton: ( localize(13751, "Retry"))
+                primaryButton: ( localize(13752, "Retry"))
             });
             return confirmed;
         }
@@ -696,17 +696,17 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             this.dialogService.prompt({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13752,
+                    13753,
                     "An error occurred while signing up for the GitHub Copilot Free plan."
                 )),
                 detail: logDetails,
                 buttons: [
                     {
-                        label: ( localize(13753, "OK")),
+                        label: ( localize(13754, "OK")),
                         run: () => { }
                     },
                     {
-                        label: ( localize(13754, "Learn More")),
+                        label: ( localize(13755, "Learn More")),
                         run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
                     }
                 ]

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

@@ -2,18 +2,18 @@
 import { localize } from '../../../../nls.js';
 
 const idDescription = ( localize(
-    13807,
+    13808,
     "The input's id is used to associate an input with a variable of the form ${input:id}."
 ));
-const typeDescription = ( localize(13808, "The type of user input prompt to use."));
-const descriptionDescription = ( localize(13809, "The description is shown when the user is prompted for input."));
-const defaultDescription = ( localize(13810, "The default value for the input."));
+const typeDescription = ( localize(13809, "The type of user input prompt to use."));
+const descriptionDescription = ( localize(13810, "The description is shown when the user is prompted for input."));
+const defaultDescription = ( localize(13811, "The default value for the input."));
 const inputsSchema = {
     definitions: {
         inputs: {
             type: 'array',
             description: ( localize(
-                13811,
+                13812,
                 'User inputs. Used for defining user input prompts, such as free string input or a choice from several options.'
             )),
             items: {
@@ -33,7 +33,7 @@ const inputsSchema = {
                                 enum: ['promptString'],
                                 enumDescriptions: [
                                     ( localize(
-                                    13812,
+                                    13813,
                                     "The 'promptString' type opens an input box to ask the user for input."
                                 )),
                                 ]
@@ -49,7 +49,7 @@ const inputsSchema = {
                             password: {
                                 type: 'boolean',
                                 description: ( localize(
-                                    13813,
+                                    13814,
                                     "Controls if a password input is shown. Password input hides the typed text."
                                 )),
                             },
@@ -69,7 +69,7 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['pickString'],
                                 enumDescriptions: [
-                                    ( localize(13814, "The 'pickString' type shows a selection list.")),
+                                    ( localize(13815, "The 'pickString' type shows a selection list.")),
                                 ]
                             },
                             description: {
@@ -82,7 +82,7 @@ const inputsSchema = {
                             },
                             options: {
                                 type: 'array',
-                                description: ( localize(13815, "An array of strings that defines the options for a quick pick.")),
+                                description: ( localize(13816, "An array of strings that defines the options for a quick pick.")),
                                 items: {
                                     oneOf: [
                                         {
@@ -95,11 +95,11 @@ const inputsSchema = {
                                             properties: {
                                                 label: {
                                                     type: 'string',
-                                                    description: ( localize(13816, "Label for the option."))
+                                                    description: ( localize(13817, "Label for the option."))
                                                 },
                                                 value: {
                                                     type: 'string',
-                                                    description: ( localize(13817, "Value for the option."))
+                                                    description: ( localize(13818, "Value for the option."))
                                                 }
                                             }
                                         }
@@ -122,26 +122,26 @@ const inputsSchema = {
                                 description: typeDescription,
                                 enum: ['command'],
                                 enumDescriptions: [
-                                    ( localize(13818, "The 'command' type executes a command.")),
+                                    ( localize(13819, "The 'command' type executes a command.")),
                                 ]
                             },
                             command: {
                                 type: 'string',
-                                description: ( localize(13819, "The command to execute for this input variable."))
+                                description: ( localize(13820, "The command to execute for this input variable."))
                             },
                             args: {
                                 oneOf: [
                                     {
                                         type: 'object',
-                                        description: ( localize(13820, "Optional arguments passed to the command."))
+                                        description: ( localize(13821, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'array',
-                                        description: ( localize(13820, "Optional arguments passed to the command."))
+                                        description: ( localize(13821, "Optional arguments passed to the command."))
                                     },
                                     {
                                         type: 'string',
-                                        description: ( localize(13820, "Optional arguments passed to the command."))
+                                        description: ( localize(13821, "Optional arguments passed to the command."))
                                     }
                                 ]
                             }

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

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

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

@@ -81,7 +81,7 @@ class AbstractVariableResolverService {
                 return normalizeDriveLetter(filePath);
             }
             throw ( new VariableError(variableKind, ( localize(
-                13822,
+                13823,
                 "Variable {0} can not be resolved. Please open an editor.",
                 replacement.id
             ))));
@@ -95,7 +95,7 @@ class AbstractVariableResolverService {
                 }
             }
             throw ( new VariableError(variableKind, ( localize(
-                13823,
+                13824,
                 "Variable {0}: can not find workspace folder of '{1}'.",
                 replacement.id,
                 basename(filePath)
@@ -108,7 +108,7 @@ class AbstractVariableResolverService {
                     return folder;
                 }
                 throw ( new VariableError(variableKind, ( localize(
-                    13824,
+                    13825,
                     "Variable {0} can not be resolved. No such folder '{1}'.",
                     variableKind,
                     argument
@@ -119,13 +119,13 @@ class AbstractVariableResolverService {
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
                 throw ( new VariableError(variableKind, ( localize(
-                    13825,
+                    13826,
                     "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
                     variableKind
                 ))));
             }
             throw ( new VariableError(variableKind, ( localize(
-                13826,
+                13827,
                 "Variable {0} can not be resolved. Please open a folder.",
                 variableKind
             ))));
@@ -142,7 +142,7 @@ class AbstractVariableResolverService {
                     return '';
                 }
                 throw ( new VariableError(VariableKind.Env, ( localize(
-                    13827,
+                    13828,
                     "Variable {0} can not be resolved because no environment variable name is given.",
                     replacement.id
                 ))));
@@ -151,7 +151,7 @@ class AbstractVariableResolverService {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            13828,
+                            13829,
                             "Variable {0} can not be resolved because setting '{1}' not found.",
                             replacement.id,
                             argument
@@ -159,7 +159,7 @@ class AbstractVariableResolverService {
                     }
                     if (isObject(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            13829,
+                            13830,
                             "Variable {0} can not be resolved because '{1}' is a structured value.",
                             replacement.id,
                             argument
@@ -168,7 +168,7 @@ class AbstractVariableResolverService {
                     return config;
                 }
                 throw ( new VariableError(VariableKind.Config, ( localize(
-                    13830,
+                    13831,
                     "Variable {0} can not be resolved because no settings name is given.",
                     replacement.id
                 ))));
@@ -181,7 +181,7 @@ class AbstractVariableResolverService {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
                         throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                            13831,
+                            13832,
                             "Variable {0} can not be resolved because the extension {1} is not installed.",
                             replacement.id,
                             argument
@@ -190,7 +190,7 @@ class AbstractVariableResolverService {
                     return this.fsPath(ext.extensionLocation);
                 }
                 throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                    13832,
+                    13833,
                     "Variable {0} can not be resolved because no extension name is given.",
                     replacement.id
                 ))));
@@ -218,7 +218,7 @@ class AbstractVariableResolverService {
                             return environment.userHome;
                         }
                         throw ( new VariableError(VariableKind.UserHome, ( localize(
-                            13833,
+                            13834,
                             "Variable {0} can not be resolved. UserHome path is not defined",
                             replacement.id
                         ))));
@@ -228,7 +228,7 @@ class AbstractVariableResolverService {
                             return lineNumber;
                         }
                         throw ( new VariableError(VariableKind.LineNumber, ( localize(
-                            13834,
+                            13835,
                             "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
                             replacement.id
                         ))));
@@ -239,7 +239,7 @@ class AbstractVariableResolverService {
                             return columnNumber;
                         }
                         throw ( new Error(( localize(
-                            13835,
+                            13836,
                             "Variable {0} can not be resolved. Make sure to have a column selected in the active editor.",
                             replacement.id
                         ))));
@@ -250,7 +250,7 @@ class AbstractVariableResolverService {
                             return selectedText;
                         }
                         throw ( new VariableError(VariableKind.SelectedText, ( localize(
-                            13836,
+                            13837,
                             "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
                             replacement.id
                         ))));
@@ -322,7 +322,7 @@ class AbstractVariableResolverService {
                 return v;
             }
             throw ( new VariableError(variableKind, ( localize(
-                13837,
+                13838,
                 "Variable {0} can not be resolved because the command has no value.",
                 match
             ))));

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -16,7 +16,7 @@ const editorAssociationsConfigurationNode = {
         'workbench.editorAssociations': {
             type: 'object',
             markdownDescription: ( localize(
-                13891,
+                13892,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {