@codingame/monaco-vscode-api 11.0.0 → 11.0.2

package/vscode/src/vs/editor/contrib/quickAccess/browser/gotoLineQuickAccess.js

@@ -9,7 +9,7 @@ class AbstractGotoLineQuickAccessProvider extends AbstractEditorNavigationQuickA
         super({ canAcceptInBackground: true });
     }
     provideWithoutTextEditor(picker) {
-        const label = ( localize(4736, "Open a text editor first to go to a line."));
+        const label = ( localize(4650, "Open a text editor first to go to a line."));
         picker.items = [{ label }];
         picker.ariaLabel = label;
         return Disposable.None;
@@ -78,15 +78,15 @@ class AbstractGotoLineQuickAccessProvider extends AbstractEditorNavigationQuickA
     getPickLabel(editor, lineNumber, column) {
         if (this.isValidLineNumber(editor, lineNumber)) {
             if (this.isValidColumn(editor, lineNumber, column)) {
-                return ( localize(4737, "Go to line {0} and character {1}.", lineNumber, column));
+                return ( localize(4651, "Go to line {0} and character {1}.", lineNumber, column));
             }
-            return ( localize(4738, "Go to line {0}.", lineNumber));
+            return ( localize(4652, "Go to line {0}.", lineNumber));
         }
         const position = editor.getPosition() || { lineNumber: 1, column: 1 };
         const lineCount = this.lineCount(editor);
         if (lineCount > 1) {
             return ( localize(
-                4739,
+                4653,
                 "Current Line: {0}, Character: {1}. Type a line number between 1 and {2} to navigate to.",
                 position.lineNumber,
                 position.column,
@@ -94,7 +94,7 @@ class AbstractGotoLineQuickAccessProvider extends AbstractEditorNavigationQuickA
             ));
         }
         return ( localize(
-            4740,
+            4654,
             "Current Line: {0}, Character: {1}. Type a line number to navigate to.",
             position.lineNumber,
             position.column

package/vscode/src/vs/editor/contrib/quickAccess/browser/gotoSymbolQuickAccess.js

@@ -29,7 +29,7 @@ let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
     }
     provideWithoutTextEditor(picker) {
         this.provideLabelPick(picker, ( localize(
-            4741,
+            4655,
             "To go to a symbol, first open a text editor with symbol information."
         )));
         return Disposable.None;
@@ -47,7 +47,7 @@ let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
     }
     doProvideWithoutEditorSymbols(context, model, picker, token) {
         const disposables = ( (new DisposableStore()));
-        this.provideLabelPick(picker, ( localize(4742, "The active text editor does not provide symbol information.")));
+        this.provideLabelPick(picker, ( localize(4656, "The active text editor does not provide symbol information.")));
         (async () => {
             const result = await this.waitForLanguageSymbolRegistry(model, disposables);
             if (!result || token.isCancellationRequested) {
@@ -118,10 +118,10 @@ let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
                 }
                 else {
                     if (query.original.length > 0) {
-                        this.provideLabelPick(picker, ( localize(4743, "No matching editor symbols")));
+                        this.provideLabelPick(picker, ( localize(4657, "No matching editor symbols")));
                     }
                     else {
-                        this.provideLabelPick(picker, ( localize(4744, "No editor symbols")));
+                        this.provideLabelPick(picker, ( localize(4658, "No editor symbols")));
                     }
                 }
             }
@@ -163,7 +163,7 @@ let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
         if (openSideBySideDirection) {
             buttons = [{
                     iconClass: openSideBySideDirection === 'right' ? ThemeIcon.asClassName(Codicon.splitHorizontal) : ThemeIcon.asClassName(Codicon.splitVertical),
-                    tooltip: openSideBySideDirection === 'right' ? ( localize(4745, "Open to the Side")) : ( localize(4746, "Open to the Bottom"))
+                    tooltip: openSideBySideDirection === 'right' ? ( localize(4659, "Open to the Side")) : ( localize(4660, "Open to the Bottom"))
                 }];
         }
         const filteredSymbolPicks = [];
@@ -263,7 +263,7 @@ let AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
         }
         else if (sortedFilteredSymbolPicks.length > 0) {
             symbolPicks = [
-                { label: ( localize(4747, "symbols ({0})", filteredSymbolPicks.length)), type: 'separator' },
+                { label: ( localize(4661, "symbols ({0})", filteredSymbolPicks.length)), type: 'separator' },
                 ...sortedFilteredSymbolPicks
             ];
         }
@@ -310,33 +310,33 @@ AbstractGotoSymbolQuickAccessProvider = AbstractGotoSymbolQuickAccessProvider_1
     ( (__param(0, ILanguageFeaturesService))),
     ( (__param(1, IOutlineModelService)))
 ], AbstractGotoSymbolQuickAccessProvider)));
-const FALLBACK_NLS_SYMBOL_KIND = ( localize(4748, "properties ({0})"));
+const FALLBACK_NLS_SYMBOL_KIND = ( localize(4662, "properties ({0})"));
 const NLS_SYMBOL_KIND_CACHE = {
-    [5 ]: ( localize(4749, "methods ({0})")),
-    [11 ]: ( localize(4750, "functions ({0})")),
-    [8 ]: ( localize(4751, "constructors ({0})")),
-    [12 ]: ( localize(4752, "variables ({0})")),
-    [4 ]: ( localize(4753, "classes ({0})")),
-    [22 ]: ( localize(4754, "structs ({0})")),
-    [23 ]: ( localize(4755, "events ({0})")),
-    [24 ]: ( localize(4756, "operators ({0})")),
-    [10 ]: ( localize(4757, "interfaces ({0})")),
-    [2 ]: ( localize(4758, "namespaces ({0})")),
-    [3 ]: ( localize(4759, "packages ({0})")),
-    [25 ]: ( localize(4760, "type parameters ({0})")),
-    [1 ]: ( localize(4761, "modules ({0})")),
-    [6 ]: ( localize(4748, "properties ({0})")),
-    [9 ]: ( localize(4762, "enumerations ({0})")),
-    [21 ]: ( localize(4763, "enumeration members ({0})")),
-    [14 ]: ( localize(4764, "strings ({0})")),
-    [0 ]: ( localize(4765, "files ({0})")),
-    [17 ]: ( localize(4766, "arrays ({0})")),
-    [15 ]: ( localize(4767, "numbers ({0})")),
-    [16 ]: ( localize(4768, "booleans ({0})")),
-    [18 ]: ( localize(4769, "objects ({0})")),
-    [19 ]: ( localize(4770, "keys ({0})")),
-    [7 ]: ( localize(4771, "fields ({0})")),
-    [13 ]: ( localize(4772, "constants ({0})"))
+    [5 ]: ( localize(4663, "methods ({0})")),
+    [11 ]: ( localize(4664, "functions ({0})")),
+    [8 ]: ( localize(4665, "constructors ({0})")),
+    [12 ]: ( localize(4666, "variables ({0})")),
+    [4 ]: ( localize(4667, "classes ({0})")),
+    [22 ]: ( localize(4668, "structs ({0})")),
+    [23 ]: ( localize(4669, "events ({0})")),
+    [24 ]: ( localize(4670, "operators ({0})")),
+    [10 ]: ( localize(4671, "interfaces ({0})")),
+    [2 ]: ( localize(4672, "namespaces ({0})")),
+    [3 ]: ( localize(4673, "packages ({0})")),
+    [25 ]: ( localize(4674, "type parameters ({0})")),
+    [1 ]: ( localize(4675, "modules ({0})")),
+    [6 ]: ( localize(4662, "properties ({0})")),
+    [9 ]: ( localize(4676, "enumerations ({0})")),
+    [21 ]: ( localize(4677, "enumeration members ({0})")),
+    [14 ]: ( localize(4678, "strings ({0})")),
+    [0 ]: ( localize(4679, "files ({0})")),
+    [17 ]: ( localize(4680, "arrays ({0})")),
+    [15 ]: ( localize(4681, "numbers ({0})")),
+    [16 ]: ( localize(4682, "booleans ({0})")),
+    [18 ]: ( localize(4683, "objects ({0})")),
+    [19 ]: ( localize(4684, "keys ({0})")),
+    [7 ]: ( localize(4685, "fields ({0})")),
+    [13 ]: ( localize(4686, "constants ({0})"))
 };
 
 export { AbstractGotoSymbolQuickAccessProvider };

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

@@ -24,7 +24,7 @@ import { IQuickInputService } from '../../../../platform/quickinput/common/quick
 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(1596, '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) {
@@ -43,19 +43,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: ( localize(1597, '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(1598, '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(1599, 'This document contains many invisible unicode characters')),
+                        message: ( localize(1594, 'This document contains many invisible unicode characters')),
                         command: ( (new DisableHighlightingOfInvisibleCharactersAction())),
                     };
                 }
@@ -322,7 +322,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = ( localize(1600, 'Configure Unicode Highlight Options'));
+const configureUnicodeHighlightOptionsStr = ( localize(1595, 'Configure Unicode Highlight Options'));
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _languageService, _openerService) {
         this._editor = _editor;
@@ -355,7 +355,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 case 0 : {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
                         reason = ( localize(
-                            1601,
+                            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))
@@ -363,7 +363,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     }
                     else {
                         reason = ( localize(
-                            1602,
+                            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))
@@ -372,10 +372,10 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                     break;
                 }
                 case 1 :
-                    reason = ( localize(1603, 'The character {0} is invisible.', codePointStr));
+                    reason = ( localize(1598, 'The character {0} is invisible.', codePointStr));
                     break;
                 case 2 :
-                    reason = ( localize(1604, '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)))) {
@@ -388,7 +388,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = ( localize(1605, 'Adjust settings'));
+            const adjustSettings = ( localize(1600, 'Adjust settings'));
             const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
             const markdown = ( (new MarkdownString('', true)))
                 .appendMarkdown(reason)
@@ -460,11 +460,11 @@ class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1606, '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(1607, 'Disable Highlight In Comments'));
+        this.shortLabel = ( localize(1602, 'Disable Highlight In Comments'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -481,11 +481,11 @@ class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1608, '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(1609, 'Disable Highlight In Strings'));
+        this.shortLabel = ( localize(1604, 'Disable Highlight In Strings'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -502,11 +502,11 @@ class DisableHighlightingOfAmbiguousCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: ( localize(1610, 'Disable highlighting of ambiguous characters')),
+            label: ( localize(1605, 'Disable highlighting of ambiguous characters')),
             alias: 'Disable highlighting of ambiguous characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1611, 'Disable Ambiguous Highlight'));
+        this.shortLabel = ( localize(1606, 'Disable Ambiguous Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -523,11 +523,11 @@ class DisableHighlightingOfInvisibleCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            label: ( localize(1612, 'Disable highlighting of invisible characters')),
+            label: ( localize(1607, 'Disable highlighting of invisible characters')),
             alias: 'Disable highlighting of invisible characters',
             precondition: undefined
         });
-        this.shortLabel = ( localize(1613, 'Disable Invisible Highlight'));
+        this.shortLabel = ( localize(1608, 'Disable Invisible Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -544,11 +544,11 @@ class DisableHighlightingOfNonBasicAsciiCharactersAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            label: ( localize(1614, '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(1615, 'Disable Non ASCII Highlight'));
+        this.shortLabel = ( localize(1610, 'Disable Non ASCII Highlight'));
     }
     async run(accessor, editor, args) {
         const configurationService = accessor?.get(IConfigurationService);
@@ -565,7 +565,7 @@ class ShowExcludeOptions extends EditorAction {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            label: ( localize(1616, "Show Exclude Options")),
+            label: ( localize(1611, "Show Exclude Options")),
             alias: 'Show Exclude Options',
             precondition: undefined
         });
@@ -578,13 +578,13 @@ class ShowExcludeOptions extends EditorAction {
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
                 return ( localize(
-                    1617,
+                    1612,
                     'Exclude {0} (invisible character) from being highlighted',
                     codePointToHex(codePoint)
                 ));
             }
             return ( localize(
-                1618,
+                1613,
                 'Exclude {0} from being highlighted',
                 `${codePointToHex(codePoint)} "${char}"`
             ));
@@ -594,7 +594,7 @@ class ShowExcludeOptions extends EditorAction {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
                     label: ( localize(
-                        1619,
+                        1614,
                         "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(1591, "Unusual Line Terminators")),
-                message: ( localize(1592, "Detected unusual line terminators")),
+                title: ( localize(1615, "Unusual Line Terminators")),
+                message: ( localize(1616, "Detected unusual line terminators")),
                 detail: ( localize(
-                    1593,
+                    1617,
                     "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(1594, "&&Remove Unusual Line Terminators")),
-                cancelButton: ( localize(1595, "Ignore"))
+                primaryButton: ( localize(1618, "&&Remove Unusual Line Terminators")),
+                cancelButton: ( localize(1619, "Ignore"))
             });
         }
         finally {

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(1806, 'Error at Position')),
+        name: ( localize(2259, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1807, 'Error')),
+        announcementMessage: ( localize(2260, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1808, 'Warning at Position')),
+        name: ( localize(2261, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1809, 'Warning')),
+        announcementMessage: ( localize(2262, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1810, 'Error on Line')),
+        name: ( localize(2263, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1811, 'Error on Line')),
+        announcementMessage: ( localize(2264, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1812, 'Warning on Line')),
+        name: ( localize(2265, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1813, 'Warning on Line')),
+        announcementMessage: ( localize(2266, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1814, 'Folded Area on Line')),
+        name: ( localize(2267, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1815, 'Folded')),
+        announcementMessage: ( localize(2268, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1816, 'Breakpoint on Line')),
+        name: ( localize(2269, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1817, 'Breakpoint')),
+        announcementMessage: ( localize(2270, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1818, 'Inline Suggestion on Line')),
+        name: ( localize(2271, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1819, 'Terminal Quick Fix')),
+        name: ( localize(2272, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1820, 'Quick Fix')),
+        announcementMessage: ( localize(2273, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1821, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(2274, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1822, 'Breakpoint')),
+        announcementMessage: ( localize(2275, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1823, 'No Inlay Hints on Line')),
+        name: ( localize(2276, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1824, 'No Inlay Hints')),
+        announcementMessage: ( localize(2277, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1825, 'Task Completed')),
+        name: ( localize(2278, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1826, 'Task Completed')),
+        announcementMessage: ( localize(2279, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1827, 'Task Failed')),
+        name: ( localize(2280, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1828, 'Task Failed')),
+        announcementMessage: ( localize(2281, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1829, 'Terminal Command Failed')),
+        name: ( localize(2282, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1830, 'Command Failed')),
+        announcementMessage: ( localize(2283, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1831, 'Terminal Command Succeeded')),
+        name: ( localize(2284, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(1832, 'Command Succeeded')),
+        announcementMessage: ( localize(2285, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1833, 'Terminal Bell')),
+        name: ( localize(2286, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1834, 'Terminal Bell')),
+        announcementMessage: ( localize(2287, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1835, 'Notebook Cell Completed')),
+        name: ( localize(2288, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1836, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(2289, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1837, 'Notebook Cell Failed')),
+        name: ( localize(2290, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1838, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(2291, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1839, 'Diff Line Inserted')),
+        name: ( localize(2292, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1840, 'Diff Line Deleted')),
+        name: ( localize(2293, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1841, 'Diff Line Modified')),
+        name: ( localize(2294, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1842, 'Chat Request Sent')),
+        name: ( localize(2295, 'Chat Request Sent')),
         sound: Sound.chatRequestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1843, 'Chat Request Sent')),
+        announcementMessage: ( localize(2296, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1844, 'Chat Response Received')),
+        name: ( localize(2297, '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(1845, 'Progress')),
+        name: ( localize(2298, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1846, 'Progress')),
+        announcementMessage: ( localize(2299, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1847, 'Clear')),
+        name: ( localize(2300, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1848, 'Clear')),
+        announcementMessage: ( localize(2301, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1849, 'Save')),
+        name: ( localize(2302, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1850, 'Save')),
+        announcementMessage: ( localize(2303, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1851, 'Format')),
+        name: ( localize(2304, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1852, 'Format')),
+        announcementMessage: ( localize(2305, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1853, 'Voice Recording Started')),
+        name: ( localize(2306, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1854, 'Voice Recording Stopped')),
+        name: ( localize(2307, '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(4590, 'View')),
-    Help: ( localize2(4591, 'Help')),
-    Test: ( localize2(4592, 'Test')),
-    File: ( localize2(4593, 'File')),
-    Preferences: ( localize2(4594, 'Preferences')),
-    Developer: ( localize2(4595, "Developer")),
+    View: ( localize2(4499, 'View')),
+    Help: ( localize2(4500, 'Help')),
+    Test: ( localize2(4501, 'Test')),
+    File: ( localize2(4502, 'File')),
+    Preferences: ( localize2(4503, 'Preferences')),
+    Developer: ( localize2(4504, "Developer")),
 })));
 
 export { Categories };