@codingame/monaco-vscode-api 7.1.1 → 8.0.1

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

@@ -26,7 +26,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(1898, 'Icon shown with a warning message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(1412, '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) {
@@ -45,19 +45,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1899, 'This document contains many non-basic ASCII unicode characters')),
+                        message: ( localize(1413, 'This document contains many non-basic ASCII unicode characters')),
                         command: ( (new DisableHighlightingOfNonBasicAsciiCharactersAction())),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: ( localize(1900, 'This document contains many ambiguous unicode characters')),
+                        message: ( localize(1414, 'This document contains many ambiguous unicode characters')),
                         command: ( (new DisableHighlightingOfAmbiguousCharactersAction())),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: ( localize(1901, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1415, 'This document contains many invisible unicode characters')),
                         command: ( (new DisableHighlightingOfInvisibleCharactersAction())),
                     };
                 }
@@ -324,7 +324,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1902, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1416, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -357,7 +357,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case UnicodeHighlighterReasonKind.Ambiguous: {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1903,
+                            1417,
                             '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))
@@ -365,7 +365,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1904,
+                            1418,
                             'The character {0} could be confused with the character {1}, which is more common in source code.',
                             codePointStr,
                             formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0))
@@ -374,10 +374,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case UnicodeHighlighterReasonKind.Invisible:
-                    reason = ( localize(1905, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1419, 'The character {0} is invisible.', codePointStr));
                     break;
                 case UnicodeHighlighterReasonKind.NonBasicAscii:
-                    reason = ( localize(1906, 'The character {0} is not a basic ASCII character.', codePointStr));
+                    reason = ( localize(1420, 'The character {0} is not a basic ASCII character.', codePointStr));
                     break;
             }
             if (( (existedReason.has(reason)))) {
@@ -390,7 +390,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1907, 'Adjust settings'));
+            const adjustSettings = ( localize(1421, 'Adjust settings'));
             const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
             const markdown = ( (new MarkdownString('', true)))
                 .appendMarkdown(reason)
@@ -462,11 +462,11 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1908, 'Disable highlighting of characters in comments')),
+            label: ( localize(1422, 'Disable highlighting of characters in comments')),
             alias: 'Disable highlighting of characters in comments',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1909, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1423, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -483,11 +483,11 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1910, 'Disable highlighting of characters in strings')),
+            label: ( localize(1424, 'Disable highlighting of characters in strings')),
             alias: 'Disable highlighting of characters in strings',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1911, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1425, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -504,11 +504,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1912, 'Disable highlighting of ambiguous characters')),
+            label: ( localize(1426, 'Disable highlighting of ambiguous characters')),
             alias: 'Disable highlighting of ambiguous characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1913, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1427, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -525,11 +525,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            label: ( localize(1914, 'Disable highlighting of invisible characters')),
+            label: ( localize(1428, 'Disable highlighting of invisible characters')),
             alias: 'Disable highlighting of invisible characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1915, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1429, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -546,11 +546,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            label: ( localize(1916, 'Disable highlighting of non basic ASCII characters')),
+            label: ( localize(1430, 'Disable highlighting of non basic ASCII characters')),
             alias: 'Disable highlighting of non basic ASCII characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1917, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1431, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -567,7 +567,7 @@ class ShowExcludeOptions extends EditorAction {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            label: ( localize(1918, "Show Exclude Options")),
+            label: ( localize(1432, "Show Exclude Options")),
             alias: 'Show Exclude Options',
             precondition: undefined
         });
@@ -580,13 +580,13 @@ class ShowExcludeOptions extends EditorAction {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return ( localize(
-                    1919,
+                    1433,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 ));
             }
             return ( localize(
-                1920,
+                1434,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             ));
@@ -596,7 +596,7 @@ class ShowExcludeOptions extends EditorAction {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1921,
+                        1435,
                         "Allow unicode characters that are more common in the language \"{0}\".",
                         locale
                     )),

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

@@ -68,15 +68,15 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: ( localize(1922, "Unusual Line Terminators")),
-                message: ( localize(1923, "Detected unusual line terminators")),
+                title: ( localize(1436, "Unusual Line Terminators")),
+                message: ( localize(1437, "Detected unusual line terminators")),
                 detail: ( localize(
-                    1924,
+                    1438,
                     "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.",
                     basename(model.uri)
                 )),
-                primaryButton: ( localize(1925, "&&Remove Unusual Line Terminators")),
-                cancelButton: ( localize(1926, "Ignore"))
+                primaryButton: ( localize(1439, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localize(1440, "Ignore"))
             });
         }
         finally {

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(
-    5225,
+    5170,
     '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(
-    5226,
+    5171,
     '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(
-    5227,
+    5172,
     '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(
-    5228,
+    5173,
     'Border color of a symbol during read-access, like reading a variable.'
 )));
 registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, ( localize(
-    5229,
+    5174,
     'Border color of a symbol during write-access, like writing to a variable.'
 )));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5230, "Border color of a textual occurrence for a symbol.")));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, ( localize(5175, "Border color of a textual occurrence for a symbol.")));
 const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', ( localize(
-    5231,
+    5176,
     '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(
-    5232,
+    5177,
     '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(
-    5233,
+    5178,
     '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

@@ -691,7 +691,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize(1927, "Go to Next Symbol Highlight")),
+            label: ( localize(1441, "Go to Next Symbol Highlight")),
             alias: 'Go to Next Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -706,7 +706,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize(1928, "Go to Previous Symbol Highlight")),
+            label: ( localize(1442, "Go to Previous Symbol Highlight")),
             alias: 'Go to Previous Symbol Highlight',
             precondition: ctxHasWordHighlights,
             kbOpts: {
@@ -721,7 +721,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize(1929, "Trigger Symbol Highlight")),
+            label: ( localize(1443, "Trigger Symbol Highlight")),
             alias: 'Trigger Symbol Highlight',
             precondition: ( (ctxHasWordHighlights.toNegated())),
             kbOpts: {

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

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

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

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

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

@@ -1,10 +1,10 @@
 import { localize2 } from '../../../nls.js';
 const Categories = ( (Object.freeze({
-    View: ( localize2(4492, 'View')),
-    Help: ( localize2(4493, 'Help')),
-    Test: ( localize2(4494, 'Test')),
-    File: ( localize2(4495, 'File')),
-    Preferences: ( localize2(4496, 'Preferences')),
-    Developer: ( localize2(4497, "Developer")),
+    View: ( localize2(4505, 'View')),
+    Help: ( localize2(4506, 'Help')),
+    Test: ( localize2(4507, 'Test')),
+    File: ( localize2(4508, 'File')),
+    Preferences: ( localize2(4509, 'Preferences')),
+    Developer: ( localize2(4510, "Developer")),
 })));
 export { Categories };

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

@@ -24,9 +24,9 @@ import '../../theme/common/colors/minimapColors.js';
 import '../../theme/common/colors/miscColors.js';
 import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(9867, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(9848, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( (new RawContextKey('codeActionMenuVisible', false, ( localize(9868, "Whether the action widget list is visible")))))
+    Visible: ( (new RawContextKey('codeActionMenuVisible', false, ( localize(9849, "Whether the action widget list is visible")))))
 };
 const IActionWidgetService = ( (createDecorator('actionWidgetService')));
 let ActionWidgetService = class ActionWidgetService extends Disposable {
@@ -131,7 +131,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(9869, "Hide action widget")),
+            title: ( localize2(9850, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -148,7 +148,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(9870, "Select previous action")),
+            title: ( localize2(9851, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -169,7 +169,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(9871, "Select next action")),
+            title: ( localize2(9852, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -190,7 +190,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(9872, "Accept selected action")),
+            title: ( localize2(9853, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -210,7 +210,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(9873, "Preview selected action")),
+            title: ( localize2(9854, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,