@codingame/monaco-vscode-api 14.0.3 → 14.0.4

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(10492, 'Errored')),
-    [TestResultState.Failed]: ( localize(10493, 'Failed')),
-    [TestResultState.Passed]: ( localize(10494, 'Passed')),
-    [TestResultState.Queued]: ( localize(10495, 'Queued')),
-    [TestResultState.Running]: ( localize(10496, 'Running')),
-    [TestResultState.Skipped]: ( localize(10497, 'Skipped')),
-    [TestResultState.Unset]: ( localize(10498, 'Not yet run')),
+    [TestResultState.Errored]: ( localize(10493, 'Errored')),
+    [TestResultState.Failed]: ( localize(10494, 'Failed')),
+    [TestResultState.Passed]: ( localize(10495, 'Passed')),
+    [TestResultState.Queued]: ( localize(10496, 'Queued')),
+    [TestResultState.Running]: ( localize(10497, 'Running')),
+    [TestResultState.Skipped]: ( localize(10498, 'Skipped')),
+    [TestResultState.Unset]: ( localize(10499, 'Not yet run')),
 };
-const labelForTestInState = (label, state) => ( localize(10499, '{0} ({1})', stripIcons(label), testStateNames[state]));
+const labelForTestInState = (label, state) => ( localize(10500, '{0} ({1})', stripIcons(label), testStateNames[state]));
 const testConfigurationGroupNames = {
-    [TestRunProfileBitset.Debug]: ( localize(10500, 'Debug')),
-    [TestRunProfileBitset.Run]: ( localize(10501, 'Run')),
-    [TestRunProfileBitset.Coverage]: ( localize(10502, 'Coverage')),
+    [TestRunProfileBitset.Debug]: ( localize(10501, 'Debug')),
+    [TestRunProfileBitset.Run]: ( localize(10502, 'Run')),
+    [TestRunProfileBitset.Coverage]: ( localize(10503, 'Coverage')),
 };
 var TestCommandId;
 (function (TestCommandId) {

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(10507, 'Run')),
-    [TestRunProfileBitset.Debug]: ( localize(10508, 'Debug')),
-    [TestRunProfileBitset.Coverage]: ( localize(10509, 'Coverage')),
+    [TestRunProfileBitset.Run]: ( localize(10508, 'Run')),
+    [TestRunProfileBitset.Debug]: ( localize(10509, 'Debug')),
+    [TestRunProfileBitset.Coverage]: ( localize(10510, 'Coverage')),
 };
 const testRunProfileBitsetList = [
     TestRunProfileBitset.Run,

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

@@ -135,7 +135,7 @@ class AbstractVariableResolverService {
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw ( new VariableError(variableKind, ( localize(11539, "Variable {0} can not be resolved. Please open an editor.", match))));
+            throw ( new VariableError(variableKind, ( localize(11540, "Variable {0} can not be resolved. Please open an editor.", match))));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -146,7 +146,7 @@ class AbstractVariableResolverService {
                 }
             }
             throw ( new VariableError(variableKind, ( localize(
-                11540,
+                11541,
                 "Variable {0}: can not find workspace folder of '{1}'.",
                 match,
                 basename(filePath)
@@ -159,7 +159,7 @@ class AbstractVariableResolverService {
                     return folder;
                 }
                 throw ( new VariableError(variableKind, ( localize(
-                    11541,
+                    11542,
                     "Variable {0} can not be resolved. No such folder '{1}'.",
                     match,
                     argument
@@ -170,12 +170,12 @@ class AbstractVariableResolverService {
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
                 throw ( new VariableError(variableKind, ( localize(
-                    11542,
+                    11543,
                     "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(11543, "Variable {0} can not be resolved. Please open a folder.", match))));
+            throw ( new VariableError(variableKind, ( localize(11544, "Variable {0} can not be resolved. Please open a folder.", match))));
         };
         switch (variable) {
             case 'env':
@@ -189,7 +189,7 @@ class AbstractVariableResolverService {
                     return '';
                 }
                 throw ( new VariableError(VariableKind.Env, ( localize(
-                    11544,
+                    11545,
                     "Variable {0} can not be resolved because no environment variable name is given.",
                     match
                 ))));
@@ -198,7 +198,7 @@ class AbstractVariableResolverService {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            11545,
+                            11546,
                             "Variable {0} can not be resolved because setting '{1}' not found.",
                             match,
                             argument
@@ -206,7 +206,7 @@ class AbstractVariableResolverService {
                     }
                     if (isObject(config)) {
                         throw ( new VariableError(VariableKind.Config, ( localize(
-                            11546,
+                            11547,
                             "Variable {0} can not be resolved because '{1}' is a structured value.",
                             match,
                             argument
@@ -215,7 +215,7 @@ class AbstractVariableResolverService {
                     return config;
                 }
                 throw ( new VariableError(VariableKind.Config, ( localize(
-                    11547,
+                    11548,
                     "Variable {0} can not be resolved because no settings name is given.",
                     match
                 ))));
@@ -228,7 +228,7 @@ class AbstractVariableResolverService {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
                         throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                            11548,
+                            11549,
                             "Variable {0} can not be resolved because the extension {1} is not installed.",
                             match,
                             argument
@@ -237,7 +237,7 @@ class AbstractVariableResolverService {
                     return this.fsPath(ext.extensionLocation);
                 }
                 throw ( new VariableError(VariableKind.ExtensionInstallFolder, ( localize(
-                    11549,
+                    11550,
                     "Variable {0} can not be resolved because no extension name is given.",
                     match
                 ))));
@@ -256,7 +256,7 @@ class AbstractVariableResolverService {
                             return environment.userHome;
                         }
                         throw ( new VariableError(VariableKind.UserHome, ( localize(
-                            11550,
+                            11551,
                             "Variable {0} can not be resolved. UserHome path is not defined",
                             match
                         ))));
@@ -267,7 +267,7 @@ class AbstractVariableResolverService {
                             return lineNumber;
                         }
                         throw ( new VariableError(VariableKind.LineNumber, ( localize(
-                            11551,
+                            11552,
                             "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
                             match
                         ))));
@@ -278,7 +278,7 @@ class AbstractVariableResolverService {
                             return columnNumber;
                         }
                         throw ( new Error(( localize(
-                            11552,
+                            11553,
                             "Variable {0} can not be resolved. Make sure to have a column selected in the active editor.",
                             match
                         ))));
@@ -289,7 +289,7 @@ class AbstractVariableResolverService {
                             return selectedText;
                         }
                         throw ( new VariableError(VariableKind.SelectedText, ( localize(
-                            11553,
+                            11554,
                             "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
                             match
                         ))));
@@ -361,7 +361,7 @@ class AbstractVariableResolverService {
                 return v;
             }
             throw ( new VariableError(variableKind, ( localize(
-                11554,
+                11555,
                 "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(
-                11605,
+                11606,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {