@codingame/monaco-vscode-api 10.1.0 → 10.1.1

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidget.js

@@ -37,18 +37,18 @@ import { ItemRenderer, getAriaId } from './suggestWidgetRenderer.js';
 import { getListStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { status } from '../../../../base/browser/ui/aria/aria.js';
 var SuggestWidget_1;
-registerColor('editorSuggestWidget.background', editorWidgetBackground, ( localize(5243, 'Background color of the suggest widget.')));
-registerColor('editorSuggestWidget.border', editorWidgetBorder, ( localize(5244, 'Border color of the suggest widget.')));
-const editorSuggestWidgetForeground = registerColor('editorSuggestWidget.foreground', editorForeground, ( localize(5245, 'Foreground color of the suggest widget.')));
-registerColor('editorSuggestWidget.selectedForeground', quickInputListFocusForeground, ( localize(5246, 'Foreground color of the selected entry in the suggest widget.')));
-registerColor('editorSuggestWidget.selectedIconForeground', quickInputListFocusIconForeground, ( localize(5247, 'Icon foreground color of the selected entry in the suggest widget.')));
-const editorSuggestWidgetSelectedBackground = registerColor('editorSuggestWidget.selectedBackground', quickInputListFocusBackground, ( localize(5248, 'Background color of the selected entry in the suggest widget.')));
-registerColor('editorSuggestWidget.highlightForeground', listHighlightForeground, ( localize(5249, 'Color of the match highlights in the suggest widget.')));
+registerColor('editorSuggestWidget.background', editorWidgetBackground, ( localize(5219, 'Background color of the suggest widget.')));
+registerColor('editorSuggestWidget.border', editorWidgetBorder, ( localize(5220, 'Border color of the suggest widget.')));
+const editorSuggestWidgetForeground = registerColor('editorSuggestWidget.foreground', editorForeground, ( localize(5221, 'Foreground color of the suggest widget.')));
+registerColor('editorSuggestWidget.selectedForeground', quickInputListFocusForeground, ( localize(5222, 'Foreground color of the selected entry in the suggest widget.')));
+registerColor('editorSuggestWidget.selectedIconForeground', quickInputListFocusIconForeground, ( localize(5223, 'Icon foreground color of the selected entry in the suggest widget.')));
+const editorSuggestWidgetSelectedBackground = registerColor('editorSuggestWidget.selectedBackground', quickInputListFocusBackground, ( localize(5224, 'Background color of the selected entry in the suggest widget.')));
+registerColor('editorSuggestWidget.highlightForeground', listHighlightForeground, ( localize(5225, 'Color of the match highlights in the suggest widget.')));
 registerColor('editorSuggestWidget.focusHighlightForeground', listFocusHighlightForeground, ( localize(
-    5250,
+    5226,
     'Color of the match highlights in the suggest widget when an item is focused.'
 )));
-registerColor('editorSuggestWidgetStatus.foreground', ( (transparent(editorSuggestWidgetForeground, .5))), ( localize(5251, 'Foreground color of the suggest widget status.')));
+registerColor('editorSuggestWidgetStatus.foreground', ( (transparent(editorSuggestWidgetForeground, .5))), ( localize(5227, 'Foreground color of the suggest widget status.')));
 class PersistedWidgetSize {
     constructor(_service, editor) {
         this._service = _service;
@@ -75,8 +75,8 @@ class PersistedWidgetSize {
 }
 let SuggestWidget = class SuggestWidget {
     static { SuggestWidget_1 = this; }
-    static { this.LOADING_MESSAGE = ( localize(5252, "Loading...")); }
-    static { this.NO_SUGGESTIONS_MESSAGE = ( localize(5253, "No suggestions.")); }
+    static { this.LOADING_MESSAGE = ( localize(5228, "Loading...")); }
+    static { this.NO_SUGGESTIONS_MESSAGE = ( localize(5229, "No suggestions.")); }
     constructor(editor, _storageService, _contextKeyService, _themeService, instantiationService) {
         this.editor = editor;
         this._storageService = _storageService;
@@ -160,20 +160,20 @@ let SuggestWidget = class SuggestWidget {
             multipleSelectionSupport: false,
             accessibilityProvider: {
                 getRole: () => 'option',
-                getWidgetAriaLabel: () => ( localize(5254, "Suggest")),
+                getWidgetAriaLabel: () => ( localize(5230, "Suggest")),
                 getWidgetRole: () => 'listbox',
                 getAriaLabel: (item) => {
                     let label = item.textLabel;
                     if (typeof item.completion.label !== 'string') {
                         const { detail, description } = item.completion.label;
                         if (detail && description) {
-                            label = ( localize(5255, '{0} {1}, {2}', label, detail, description));
+                            label = ( localize(5231, '{0} {1}, {2}', label, detail, description));
                         }
                         else if (detail) {
-                            label = ( localize(5256, '{0} {1}', label, detail));
+                            label = ( localize(5232, '{0} {1}', label, detail));
                         }
                         else if (description) {
-                            label = ( localize(5257, '{0}, {1}', label, description));
+                            label = ( localize(5233, '{0}, {1}', label, description));
                         }
                     }
                     if (!item.isResolved || !this._isDetailsVisible()) {
@@ -181,7 +181,7 @@ let SuggestWidget = class SuggestWidget {
                     }
                     const { documentation, detail } = item.completion;
                     const docs = format('{0}{1}', detail || '', documentation ? (typeof documentation === 'string' ? documentation : documentation.value) : '');
-                    return ( localize(5258, "{0}, docs: {1}", label, docs));
+                    return ( localize(5234, "{0}, docs: {1}", label, docs));
                 },
             }
         })));

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

@@ -7,7 +7,7 @@ class ToggleTabFocusModeAction extends Action2 {
     constructor() {
         super({
             id: ToggleTabFocusModeAction.ID,
-            title: ( localize2(1591, 'Toggle Tab Key Moves Focus')),
+            title: ( localize2(1615, 'Toggle Tab Key Moves Focus')),
             precondition: undefined,
             keybinding: {
                 primary: 2048  | 43 ,
@@ -16,7 +16,7 @@ class ToggleTabFocusModeAction extends Action2 {
             },
             metadata: {
                 description: ( localize2(
-                    1592,
+                    1616,
                     "Determines whether the tab key moves focus around the workbench or inserts the tab character in the current editor. This is also called tab trapping, tab navigation, or tab focus mode."
                 )),
             },
@@ -28,10 +28,10 @@ class ToggleTabFocusModeAction extends Action2 {
         const newValue = !oldValue;
         TabFocus.setTabFocusMode(newValue);
         if (newValue) {
-            alert(( localize(1593, "Pressing Tab will now move focus to the next focusable element")));
+            alert(( localize(1617, "Pressing Tab will now move focus to the next focusable element")));
         }
         else {
-            alert(( localize(1594, "Pressing Tab will now insert the tab character")));
+            alert(( localize(1618, "Pressing Tab will now insert the tab character")));
         }
     }
 }

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

@@ -23,7 +23,7 @@ import { IOpenerService } from '../../../../platform/opener/common/opener.servic
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
 import { IWorkspaceTrustManagementService } from '../../../../platform/workspace/common/workspaceTrust.service.js';
-const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1595, 'Icon shown with a warning message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1591, 'Icon shown with a warning message in the extensions editor.')));
 let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
     static { this.ID = 'editor.contrib.unicodeHighlighter'; }
     constructor(_editor, _editorWorkerService, _workspaceTrustService, instantiationService) {
@@ -42,19 +42,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1596, 'This document contains many non-basic ASCII unicode characters')),
+                        message: ( localize(1592, 'This document contains many non-basic ASCII unicode characters')),
                         command: ( (new DisableHighlightingOfNonBasicAsciiCharactersAction())),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localize(1597, 'This document contains many ambiguous unicode characters')),
+                        message: ( localize(1593, 'This document contains many ambiguous unicode characters')),
                         command: ( (new DisableHighlightingOfAmbiguousCharactersAction())),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localize(1598, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1594, 'This document contains many invisible unicode characters')),
                         command: ( (new DisableHighlightingOfInvisibleCharactersAction())),
                     };
                 }
@@ -321,7 +321,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1599, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1595, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -354,7 +354,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case 0 : {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1600,
+                            1596,
                             'The character {0} could be confused with the ASCII character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -362,7 +362,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1601,
+                            1597,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -371,10 +371,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case 1 :
-                    reason = ( localize(1602, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1598, 'The character {0} is invisible.', codePointStr));
                     break;
                 case 2 :
-                    reason = ( localize(1603, 'The character {0} is not a basic ASCII character.', codePointStr));
+                    reason = ( localize(1599, 'The character {0} is not a basic ASCII character.', codePointStr));
                     break;
             }
             if (( (existedReason.has(reason)))) {
@@ -387,7 +387,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1604, 'Adjust settings'));
+            const adjustSettings = ( localize(1600, 'Adjust settings'));
             const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
             const markdown = ( (new MarkdownString('', true)))
                 .appendMarkdown(reason)
@@ -459,11 +459,11 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1605, 'Disable highlighting of characters in comments')),
+            label: ( localize(1601, 'Disable highlighting of characters in comments')),
             alias: 'Disable highlighting of characters in comments',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1606, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1602, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -480,11 +480,11 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1607, 'Disable highlighting of characters in strings')),
+            label: ( localize(1603, 'Disable highlighting of characters in strings')),
             alias: 'Disable highlighting of characters in strings',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1608, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1604, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -501,11 +501,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1609, 'Disable highlighting of ambiguous characters')),
+            label: ( localize(1605, 'Disable highlighting of ambiguous characters')),
             alias: 'Disable highlighting of ambiguous characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1610, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1606, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -522,11 +522,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            label: ( localize(1611, 'Disable highlighting of invisible characters')),
+            label: ( localize(1607, 'Disable highlighting of invisible characters')),
             alias: 'Disable highlighting of invisible characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1612, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1608, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -543,11 +543,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            label: ( localize(1613, 'Disable highlighting of non basic ASCII characters')),
+            label: ( localize(1609, 'Disable highlighting of non basic ASCII characters')),
             alias: 'Disable highlighting of non basic ASCII characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1614, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1610, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -564,7 +564,7 @@ class ShowExcludeOptions extends EditorAction {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            label: ( localize(1615, "Show Exclude Options")),
+            label: ( localize(1611, "Show Exclude Options")),
             alias: 'Show Exclude Options',
             precondition: undefined
         });
@@ -577,13 +577,13 @@ class ShowExcludeOptions extends EditorAction {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return ( localize(
-                    1616,
+                    1612,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 ));
             }
             return ( localize(
-                1617,
+                1613,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             ));
@@ -593,7 +593,7 @@ class ShowExcludeOptions extends EditorAction {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1618,
+                        1614,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),

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

@@ -16,36 +16,36 @@ import '../../../../platform/theme/common/colors/quickpickColors.js';
 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(
-    5204,
+    5180,
     '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(
-    5205,
+    5181,
     '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(
-    5206,
+    5182,
     '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(
-    5207,
+    5183,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5208,
+    5184,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5209, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5185, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    5210,
+    5186,
     '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(
-    5211,
+    5187,
     '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(
-    5212,
+    5188,
     '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/platform/accessibilitySignal/browser/accessibilitySignalService.js

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

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

@@ -193,17 +193,17 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localize(4649, "{0} ({1})", tooltip, keybindingLabel))
+            ? ( localize(4871, "{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(4649, "{0} ({1})", altTooltip, altKeybindingLabel))
+                ? ( localize(4871, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localize(
-                4650,
+                4872,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -279,10 +279,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(4651, '{1} to {0}', this._action.label, kb2));
+                this.label.textContent = ( localize(4873, '{1} to {0}', this._action.label, kb2));
             }
             else {
-                this.label.textContent = ( localize(4652, '{0} ({1})', this._action.label, kb2));
+                this.label.textContent = ( localize(4874, '{0} ({1})', this._action.label, kb2));
             }
         }
     }