@codingame/monaco-vscode-api 11.1.0 → 11.1.2

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.js

@@ -17,36 +17,36 @@ import '../../../../platform/theme/common/colors/searchColors.js';
 import { themeColorFromId, registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
 
 const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, ( localize(
-    5212,
+    5225,
     'Background color of a symbol during read-access, like reading a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightStrongBackground', { dark: '#004972B8', light: '#0e639c40', hcDark: null, hcLight: null }, ( localize(
-    5213,
+    5226,
     'Background color of a symbol during write-access, like writing to a variable. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 registerColor('editor.wordHighlightTextBackground', wordHighlightBackground, ( localize(
-    5214,
+    5227,
     'Background color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const wordHighlightBorder = registerColor('editor.wordHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5215,
+    5228,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5216,
+    5229,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5217, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5230, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    5218,
+    5231,
     'Overview ruler marker color for symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightStrongForeground = registerColor('editorOverviewRuler.wordHighlightStrongForeground', '#C0A0C0CC', ( localize(
-    5219,
+    5232,
     'Overview ruler marker color for write-access symbol highlights. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const overviewRulerWordHighlightTextForeground = registerColor('editorOverviewRuler.wordHighlightTextForeground', overviewRulerSelectionHighlightForeground, ( localize(
-    5220,
+    5233,
     'Overview ruler marker color of a textual occurrence for a symbol. The color must not be opaque so as not to hide underlying decorations.'
 )), true);
 const _WRITE_OPTIONS = ModelDecorationOptions.register({

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js

@@ -722,7 +722,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize(1620, "Go to Next Symbol Highlight")),
+            label: ( localize(1948, "Go to Next Symbol Highlight")),
             alias: 'Go to Next Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -737,7 +737,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize(1621, "Go to Previous Symbol Highlight")),
+            label: ( localize(1949, "Go to Previous Symbol Highlight")),
             alias: 'Go to Previous Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -752,7 +752,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize(1622, "Trigger Symbol Highlight")),
+            label: ( localize(1950, "Trigger Symbol Highlight")),
             alias: 'Trigger Symbol Highlight',
             precondition: undefined,
             kbOpts: {

package/vscode/src/vs/editor/contrib/wordOperations/browser/wordOperations.js

@@ -416,7 +416,7 @@ class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: ( localize(1623, "Delete Word")),
+            label: ( localize(1951, "Delete Word")),
             alias: 'Delete Word'
         });
     }

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -268,163 +268,163 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(2259, 'Error at Position')),
+        name: ( localize(2288, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(2260, 'Error')),
+        announcementMessage: ( localize(2289, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(2261, 'Warning at Position')),
+        name: ( localize(2290, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(2262, 'Warning')),
+        announcementMessage: ( localize(2291, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(2263, 'Error on Line')),
+        name: ( localize(2292, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(2264, 'Error on Line')),
+        announcementMessage: ( localize(2293, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(2265, 'Warning on Line')),
+        name: ( localize(2294, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(2266, 'Warning on Line')),
+        announcementMessage: ( localize(2295, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(2267, 'Folded Area on Line')),
+        name: ( localize(2296, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(2268, 'Folded')),
+        announcementMessage: ( localize(2297, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(2269, 'Breakpoint on Line')),
+        name: ( localize(2298, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(2270, 'Breakpoint')),
+        announcementMessage: ( localize(2299, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(2271, 'Inline Suggestion on Line')),
+        name: ( localize(2300, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(2272, 'Terminal Quick Fix')),
+        name: ( localize(2301, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(2273, 'Quick Fix')),
+        announcementMessage: ( localize(2302, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(2274, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(2303, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(2275, 'Breakpoint')),
+        announcementMessage: ( localize(2304, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(2276, 'No Inlay Hints on Line')),
+        name: ( localize(2305, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(2277, 'No Inlay Hints')),
+        announcementMessage: ( localize(2306, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(2278, 'Task Completed')),
+        name: ( localize(2307, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(2279, 'Task Completed')),
+        announcementMessage: ( localize(2308, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(2280, 'Task Failed')),
+        name: ( localize(2309, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(2281, 'Task Failed')),
+        announcementMessage: ( localize(2310, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(2282, 'Terminal Command Failed')),
+        name: ( localize(2311, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(2283, 'Command Failed')),
+        announcementMessage: ( localize(2312, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(2284, 'Terminal Command Succeeded')),
+        name: ( localize(2313, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(2285, 'Command Succeeded')),
+        announcementMessage: ( localize(2314, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(2286, 'Terminal Bell')),
+        name: ( localize(2315, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(2287, 'Terminal Bell')),
+        announcementMessage: ( localize(2316, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(2288, 'Notebook Cell Completed')),
+        name: ( localize(2317, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(2289, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(2318, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(2290, 'Notebook Cell Failed')),
+        name: ( localize(2319, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(2291, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(2320, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(2292, 'Diff Line Inserted')),
+        name: ( localize(2321, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(2293, 'Diff Line Deleted')),
+        name: ( localize(2322, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(2294, 'Diff Line Modified')),
+        name: ( localize(2323, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(2295, 'Chat Request Sent')),
+        name: ( localize(2324, 'Chat Request Sent')),
         sound: Sound.chatRequestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(2296, 'Chat Request Sent')),
+        announcementMessage: ( localize(2325, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(2297, 'Chat Response Received')),
+        name: ( localize(2326, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -437,45 +437,45 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(2298, 'Progress')),
+        name: ( localize(2327, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(2299, 'Progress')),
+        announcementMessage: ( localize(2328, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(2300, 'Clear')),
+        name: ( localize(2329, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(2301, 'Clear')),
+        announcementMessage: ( localize(2330, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(2302, 'Save')),
+        name: ( localize(2331, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(2303, 'Save')),
+        announcementMessage: ( localize(2332, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(2304, 'Format')),
+        name: ( localize(2333, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(2305, 'Format')),
+        announcementMessage: ( localize(2334, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(2306, 'Voice Recording Started')),
+        name: ( localize(2335, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(2307, 'Voice Recording Stopped')),
+        name: ( localize(2336, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'

package/vscode/src/vs/platform/action/common/actionCommonCategories.js

@@ -1,12 +1,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( (Object.freeze({
-    View: ( localize2(4485, 'View')),
-    Help: ( localize2(4486, 'Help')),
-    Test: ( localize2(4487, 'Test')),
-    File: ( localize2(4488, 'File')),
-    Preferences: ( localize2(4489, 'Preferences')),
-    Developer: ( localize2(4490, "Developer")),
+    View: ( localize2(4502, 'View')),
+    Help: ( localize2(4503, 'Help')),
+    Test: ( localize2(4504, 'Test')),
+    File: ( localize2(4505, 'File')),
+    Preferences: ( localize2(4506, 'Preferences')),
+    Developer: ( localize2(4507, "Developer")),
 })));
 
 export { Categories };

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -23,9 +23,9 @@ import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(10060, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(10071, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( (new RawContextKey('codeActionMenuVisible', false, ( localize(10061, "Whether the action widget list is visible")))))
+    Visible: ( (new RawContextKey('codeActionMenuVisible', false, ( localize(10072, "Whether the action widget list is visible")))))
 };
 const IActionWidgetService = ( (createDecorator('actionWidgetService')));
 let ActionWidgetService = class ActionWidgetService extends Disposable {
@@ -130,7 +130,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(10062, "Hide action widget")),
+            title: ( localize2(10073, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -147,7 +147,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(10063, "Select previous action")),
+            title: ( localize2(10074, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -168,7 +168,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(10064, "Select next action")),
+            title: ( localize2(10075, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -189,7 +189,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(10065, "Accept selected action")),
+            title: ( localize2(10076, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -209,7 +209,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(10066, "Preview selected action")),
+            title: ( localize2(10077, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -195,17 +195,17 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localize(4902, "{0} ({1})", tooltip, keybindingLabel))
+            ? ( localize(4570, "{0} ({1})", tooltip, keybindingLabel))
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? ( localize(4902, "{0} ({1})", altTooltip, altKeybindingLabel))
+                ? ( localize(4570, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localize(
-                4903,
+                4571,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -281,10 +281,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(4904, '{1} to {0}', this._action.label, kb2));
+                this.label.textContent = ( localize(4572, '{1} to {0}', this._action.label, kb2));
             }
             else {
-                this.label.textContent = ( localize(4905, '{0} ({1})', this._action.label, kb2));
+                this.label.textContent = ( localize(4573, '{0} ({1})', this._action.label, kb2));
             }
         }
     }

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -137,7 +137,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     else {
                         primaryActions.push(toAction({
                             id: 'label',
-                            label: ( localize(5588, "Hide")),
+                            label: ( localize(5559, "Hide")),
                             enabled: false,
                             run() { }
                         }));
@@ -151,7 +151,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( (new Separator())));
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: ( localize(5589, "Reset Menu")),
+                        label: ( localize(5560, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -8,7 +8,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: 'menu.resetHiddenStates',
-            title: ( localize2(4556, "Reset All Menus")),
+            title: ( localize2(4694, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -410,7 +410,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1282, 'Hide \'{0}\'', title)),
+        label: ( localize(825, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -428,7 +428,7 @@ function createMenuHide(menu, command, states) {
 function createConfigureKeybindingAction(commandService, keybindingService, commandId, when = undefined, enabled = true) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1283, "Configure Keybinding")),
+        label: ( localize(826, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -43,7 +43,7 @@ class ConfigurationRegistry {
         this.configurationDefaultsOverrides = ( (new Map()));
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: ( localize(472, "Default Language Configuration Overrides")),
+            title: ( localize(468, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -191,7 +191,7 @@ class ConfigurationRegistry {
             type: 'object',
             default: newDefaultOverride.value,
             description: ( localize(
-                473,
+                469,
                 "Configure settings to be overridden for the {0} language.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -451,8 +451,8 @@ class ConfigurationRegistry {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: ( localize(474, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(475, "This setting does not support per-language configuration.")),
+                description: ( localize(470, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(471, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -467,8 +467,8 @@ class ConfigurationRegistry {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: 'object',
-            description: ( localize(474, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(475, "This setting does not support per-language configuration.")),
+            description: ( localize(470, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(471, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId,
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -543,25 +543,25 @@ const configurationRegistry = ( (new ConfigurationRegistry()));
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return ( localize(476, "Cannot register an empty property"));
+        return ( localize(472, "Cannot register an empty property"));
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return ( localize(
-            477,
+            473,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         ));
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
         return ( localize(
-            478,
+            474,
             "Cannot register '{0}'. This property is already registered.",
             property
         ));
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return ( localize(
-            479,
+            475,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -504,7 +504,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1284, "A command that returns information about context keys")),
+        description: ( localize(827, "A command that returns information about context keys")),
         args: []
     }
 });

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -26,17 +26,17 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(480, "Empty context key expression"));
+const errorEmptyString = ( localize(476, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    481,
+    477,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(482, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(483, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(484, "Unexpected token"));
-const hintUnexpectedToken = ( localize(485, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(486, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(487, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(478, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(479, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(480, "Unexpected token"));
+const hintUnexpectedToken = ( localize(481, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(482, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(483, "Did you forget to put a context key?"));
 class Parser {
     static { this._parseError = ( (new Error())); }
     get lexingErrors() {
@@ -368,7 +368,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(488, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(484, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -452,8 +452,8 @@ function validateWhenClauses(whenClauses) {
                 return (
                      (parser.lexingErrors.map((se) => ({
                         errorMessage: se.additionalInfo ?
-                            ( localize(489, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                            ( localize(490, "Unexpected token.")),
+                            ( localize(485, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                            ( localize(486, "Unexpected token.")),
                         offset: se.offset,
                         length: se.lexeme.length,
                     })))