monaco-editor-core 0.55.0-dev-20251021 → 0.55.0-dev-20251022

package/esm/vs/editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js

@@ -36,7 +36,7 @@ import { Action2, registerAction2 } from '../../../../platform/actions/common/ac
 import { safeIntl } from '../../../../base/common/date.js';
 import { isModelDecorationInComment, isModelDecorationInString, isModelDecorationVisible } from '../../../common/viewModel/viewModelDecoration.js';
 import { IMarkdownRendererService } from '../../../../platform/markdown/browser/markdownRenderer.js';
-export const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, nls.localize(1523, 'Icon shown with a warning message in the extensions editor.'));
+export const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, nls.localize(1527, '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) {
@@ -56,19 +56,19 @@ let UnicodeHighlighter = class UnicodeHighlighter extends Disposable {
                 let data;
                 if (state.nonBasicAsciiCharacterCount >= max) {
                     data = {
-                        message: nls.localize(1524, 'This document contains many non-basic ASCII unicode characters'),
+                        message: nls.localize(1528, 'This document contains many non-basic ASCII unicode characters'),
                         command: new DisableHighlightingOfNonBasicAsciiCharactersAction(),
                     };
                 }
                 else if (state.ambiguousCharacterCount >= max) {
                     data = {
-                        message: nls.localize(1525, 'This document contains many ambiguous unicode characters'),
+                        message: nls.localize(1529, 'This document contains many ambiguous unicode characters'),
                         command: new DisableHighlightingOfAmbiguousCharactersAction(),
                     };
                 }
                 else if (state.invisibleCharacterCount >= max) {
                     data = {
-                        message: nls.localize(1526, 'This document contains many invisible unicode characters'),
+                        message: nls.localize(1530, 'This document contains many invisible unicode characters'),
                         command: new DisableHighlightingOfInvisibleCharactersAction(),
                     };
                 }
@@ -337,7 +337,7 @@ class ViewportUnicodeHighlighter extends Disposable {
         };
     }
 }
-const configureUnicodeHighlightOptionsStr = nls.localize(1527, 'Configure Unicode Highlight Options');
+const configureUnicodeHighlightOptionsStr = nls.localize(1531, 'Configure Unicode Highlight Options');
 let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant {
     constructor(_editor, _markdownRendererService) {
         this._editor = _editor;
@@ -369,18 +369,18 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
             switch (highlightInfo.reason.kind) {
                 case 0 /* UnicodeHighlighterReasonKind.Ambiguous */: {
                     if (isBasicASCII(highlightInfo.reason.confusableWith)) {
-                        reason = nls.localize(1528, '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)));
+                        reason = nls.localize(1532, '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)));
                     }
                     else {
-                        reason = nls.localize(1529, 'The character {0} could be confused with the character {1}, which is more common in source code.', codePointStr, formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0)));
+                        reason = nls.localize(1533, 'The character {0} could be confused with the character {1}, which is more common in source code.', codePointStr, formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0)));
                     }
                     break;
                 }
                 case 1 /* UnicodeHighlighterReasonKind.Invisible */:
-                    reason = nls.localize(1530, 'The character {0} is invisible.', codePointStr);
+                    reason = nls.localize(1534, 'The character {0} is invisible.', codePointStr);
                     break;
                 case 2 /* UnicodeHighlighterReasonKind.NonBasicAscii */:
-                    reason = nls.localize(1531, 'The character {0} is not a basic ASCII character.', codePointStr);
+                    reason = nls.localize(1535, 'The character {0} is not a basic ASCII character.', codePointStr);
                     break;
             }
             if (existedReason.has(reason)) {
@@ -393,7 +393,7 @@ let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipan
                 inComment: highlightInfo.inComment,
                 inString: highlightInfo.inString,
             };
-            const adjustSettings = nls.localize(1532, 'Adjust settings');
+            const adjustSettings = nls.localize(1536, 'Adjust settings');
             const uri = createCommandUri(ShowExcludeOptions.ID, adjustSettingsArgs);
             const markdown = new MarkdownString('', true)
                 .appendMarkdown(reason)
@@ -462,10 +462,10 @@ export class DisableHighlightingInCommentsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: nls.localize2(1541, "Disable highlighting of characters in comments"),
+            label: nls.localize2(1545, "Disable highlighting of characters in comments"),
             precondition: undefined
         });
-        this.shortLabel = nls.localize(1533, 'Disable Highlight In Comments');
+        this.shortLabel = nls.localize(1537, 'Disable Highlight In Comments');
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -481,10 +481,10 @@ export class DisableHighlightingInStringsAction extends EditorAction {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            label: nls.localize2(1542, "Disable highlighting of characters in strings"),
+            label: nls.localize2(1546, "Disable highlighting of characters in strings"),
             precondition: undefined
         });
-        this.shortLabel = nls.localize(1534, 'Disable Highlight In Strings');
+        this.shortLabel = nls.localize(1538, 'Disable Highlight In Strings');
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -501,11 +501,11 @@ export class DisableHighlightingOfAmbiguousCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-            title: nls.localize2(1543, "Disable highlighting of ambiguous characters"),
+            title: nls.localize2(1547, "Disable highlighting of ambiguous characters"),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = nls.localize(1535, 'Disable Ambiguous Highlight');
+        this.shortLabel = nls.localize(1539, 'Disable Ambiguous Highlight');
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -522,11 +522,11 @@ export class DisableHighlightingOfInvisibleCharactersAction extends Action2 {
     constructor() {
         super({
             id: DisableHighlightingOfInvisibleCharactersAction.ID,
-            title: nls.localize2(1544, "Disable highlighting of invisible characters"),
+            title: nls.localize2(1548, "Disable highlighting of invisible characters"),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = nls.localize(1536, 'Disable Invisible Highlight');
+        this.shortLabel = nls.localize(1540, 'Disable Invisible Highlight');
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -543,11 +543,11 @@ export class DisableHighlightingOfNonBasicAsciiCharactersAction extends Action2
     constructor() {
         super({
             id: DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-            title: nls.localize2(1545, "Disable highlighting of non basic ASCII characters"),
+            title: nls.localize2(1549, "Disable highlighting of non basic ASCII characters"),
             precondition: undefined,
             f1: false,
         });
-        this.shortLabel = nls.localize(1537, 'Disable Non ASCII Highlight');
+        this.shortLabel = nls.localize(1541, 'Disable Non ASCII Highlight');
     }
     async run(accessor, editor, args) {
         const configurationService = accessor.get(IConfigurationService);
@@ -564,7 +564,7 @@ export class ShowExcludeOptions extends Action2 {
     constructor() {
         super({
             id: ShowExcludeOptions.ID,
-            title: nls.localize2(1546, "Show Exclude Options"),
+            title: nls.localize2(1550, "Show Exclude Options"),
             precondition: undefined,
             f1: false,
         });
@@ -576,15 +576,15 @@ export class ShowExcludeOptions extends Action2 {
         const configurationService = accessor.get(IConfigurationService);
         function getExcludeCharFromBeingHighlightedLabel(codePoint) {
             if (InvisibleCharacters.isInvisibleCharacter(codePoint)) {
-                return nls.localize(1538, 'Exclude {0} (invisible character) from being highlighted', codePointToHex(codePoint));
+                return nls.localize(1542, 'Exclude {0} (invisible character) from being highlighted', codePointToHex(codePoint));
             }
-            return nls.localize(1539, 'Exclude {0} from being highlighted', `${codePointToHex(codePoint)} "${char}"`);
+            return nls.localize(1543, 'Exclude {0} from being highlighted', `${codePointToHex(codePoint)} "${char}"`);
         }
         const options = [];
         if (reason.kind === 0 /* UnicodeHighlighterReasonKind.Ambiguous */) {
             for (const locale of reason.notAmbiguousInLocales) {
                 options.push({
-                    label: nls.localize(1540, "Allow unicode characters that are more common in the language \"{0}\".", locale),
+                    label: nls.localize(1544, "Allow unicode characters that are more common in the language \"{0}\".", locale),
                     run: async () => {
                         excludeLocaleFromBeingHighlighted(configurationService, [locale]);
                     },

package/esm/vs/editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js

@@ -85,11 +85,11 @@ let UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extend
         try {
             this._isPresentingDialog = true;
             result = await this._dialogService.confirm({
-                title: nls.localize(1547, "Unusual Line Terminators"),
-                message: nls.localize(1548, "Detected unusual line terminators"),
-                detail: nls.localize(1549, "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: nls.localize(1550, "&&Remove Unusual Line Terminators"),
-                cancelButton: nls.localize(1551, "Ignore")
+                title: nls.localize(1551, "Unusual Line Terminators"),
+                message: nls.localize(1552, "Detected unusual line terminators"),
+                detail: nls.localize(1553, "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: nls.localize(1554, "&&Remove Unusual Line Terminators"),
+                cancelButton: nls.localize(1555, "Ignore")
             });
         }
         finally {

package/esm/vs/editor/contrib/wordHighlighter/browser/highlightDecorations.js

@@ -9,15 +9,15 @@ import { DocumentHighlightKind } from '../../../common/languages.js';
 import * as nls from '../../../../nls.js';
 import { activeContrastBorder, editorSelectionHighlight, minimapSelectionOccurrenceHighlight, overviewRulerSelectionHighlightForeground, registerColor } from '../../../../platform/theme/common/colorRegistry.js';
 import { registerThemingParticipant, themeColorFromId } from '../../../../platform/theme/common/themeService.js';
-const wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, nls.localize(1552, '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 }, nls.localize(1553, '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, nls.localize(1554, '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 }, nls.localize(1555, 'Border color of a symbol during read-access, like reading a variable.'));
-registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1556, 'Border color of a symbol during write-access, like writing to a variable.'));
-registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, nls.localize(1557, "Border color of a textual occurrence for a symbol."));
-const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', nls.localize(1558, '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', nls.localize(1559, '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, nls.localize(1560, '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 wordHighlightBackground = registerColor('editor.wordHighlightBackground', { dark: '#575757B8', light: '#57575740', hcDark: null, hcLight: null }, nls.localize(1556, '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 }, nls.localize(1557, '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, nls.localize(1558, '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 }, nls.localize(1559, 'Border color of a symbol during read-access, like reading a variable.'));
+registerColor('editor.wordHighlightStrongBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1560, 'Border color of a symbol during write-access, like writing to a variable.'));
+registerColor('editor.wordHighlightTextBorder', wordHighlightBorder, nls.localize(1561, "Border color of a textual occurrence for a symbol."));
+const overviewRulerWordHighlightForeground = registerColor('editorOverviewRuler.wordHighlightForeground', '#A0A0A0CC', nls.localize(1562, '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', nls.localize(1563, '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, nls.localize(1564, '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({
     description: 'word-highlight-strong',
     stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,

package/esm/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js

@@ -742,7 +742,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: nls.localize2(1561, "Go to Next Symbol Highlight"),
+            label: nls.localize2(1565, "Go to Next Symbol Highlight"),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -756,7 +756,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: nls.localize2(1562, "Go to Previous Symbol Highlight"),
+            label: nls.localize2(1566, "Go to Previous Symbol Highlight"),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -770,7 +770,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: nls.localize2(1563, "Trigger Symbol Highlight"),
+            label: nls.localize2(1567, "Trigger Symbol Highlight"),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

package/esm/vs/editor/contrib/wordOperations/browser/wordOperations.js

@@ -395,7 +395,7 @@ export class DeleteInsideWord extends EditorAction {
         super({
             id: 'deleteInsideWord',
             precondition: EditorContextKeys.writable,
-            label: nls.localize2(1564, "Delete Word"),
+            label: nls.localize2(1568, "Delete Word"),
         });
     }
     run(accessor, editor, args) {

package/esm/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js

@@ -69,176 +69,176 @@ export class AccessibilitySignal {
         return signal;
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: localize(1565, 'Error at Position'),
+        name: localize(1569, 'Error at Position'),
         sound: Sound.error,
-        announcementMessage: localize(1566, 'Error'),
+        announcementMessage: localize(1570, 'Error'),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: localize(1567, 'Warning at Position'),
+        name: localize(1571, 'Warning at Position'),
         sound: Sound.warning,
-        announcementMessage: localize(1568, 'Warning'),
+        announcementMessage: localize(1572, 'Warning'),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: localize(1569, 'Error on Line'),
+        name: localize(1573, 'Error on Line'),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: localize(1570, 'Error on Line'),
+        announcementMessage: localize(1574, 'Error on Line'),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: localize(1571, 'Warning on Line'),
+        name: localize(1575, 'Warning on Line'),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: localize(1572, 'Warning on Line'),
+        announcementMessage: localize(1576, 'Warning on Line'),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: localize(1573, 'Folded Area on Line'),
+        name: localize(1577, 'Folded Area on Line'),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: localize(1574, 'Folded'),
+        announcementMessage: localize(1578, 'Folded'),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: localize(1575, 'Breakpoint on Line'),
+        name: localize(1579, 'Breakpoint on Line'),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: localize(1576, 'Breakpoint'),
+        announcementMessage: localize(1580, 'Breakpoint'),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: localize(1577, 'Inline Suggestion on Line'),
+        name: localize(1581, 'Inline Suggestion on Line'),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.nextEditSuggestion = AccessibilitySignal.register({
-        name: localize(1578, 'Next Edit Suggestion on Line'),
+        name: localize(1582, 'Next Edit Suggestion on Line'),
         sound: Sound.nextEditSuggestion,
         legacySoundSettingsKey: 'audioCues.nextEditSuggestion',
         settingsKey: 'accessibility.signals.nextEditSuggestion',
-        announcementMessage: localize(1579, 'Next Edit Suggestion'),
+        announcementMessage: localize(1583, 'Next Edit Suggestion'),
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: localize(1580, 'Terminal Quick Fix'),
+        name: localize(1584, 'Terminal Quick Fix'),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: localize(1581, 'Quick Fix'),
+        announcementMessage: localize(1585, 'Quick Fix'),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: localize(1582, 'Debugger Stopped on Breakpoint'),
+        name: localize(1586, 'Debugger Stopped on Breakpoint'),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: localize(1583, 'Breakpoint'),
+        announcementMessage: localize(1587, 'Breakpoint'),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: localize(1584, 'No Inlay Hints on Line'),
+        name: localize(1588, 'No Inlay Hints on Line'),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: localize(1585, 'No Inlay Hints'),
+        announcementMessage: localize(1589, 'No Inlay Hints'),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: localize(1586, 'Task Completed'),
+        name: localize(1590, 'Task Completed'),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: localize(1587, 'Task Completed'),
+        announcementMessage: localize(1591, 'Task Completed'),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: localize(1588, 'Task Failed'),
+        name: localize(1592, 'Task Failed'),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: localize(1589, 'Task Failed'),
+        announcementMessage: localize(1593, 'Task Failed'),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: localize(1590, 'Terminal Command Failed'),
+        name: localize(1594, 'Terminal Command Failed'),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: localize(1591, 'Command Failed'),
+        announcementMessage: localize(1595, 'Command Failed'),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: localize(1592, 'Terminal Command Succeeded'),
+        name: localize(1596, 'Terminal Command Succeeded'),
         sound: Sound.terminalCommandSucceeded,
-        announcementMessage: localize(1593, 'Command Succeeded'),
+        announcementMessage: localize(1597, 'Command Succeeded'),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: localize(1594, 'Terminal Bell'),
+        name: localize(1598, 'Terminal Bell'),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: localize(1595, 'Terminal Bell'),
+        announcementMessage: localize(1599, 'Terminal Bell'),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: localize(1596, 'Notebook Cell Completed'),
+        name: localize(1600, 'Notebook Cell Completed'),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: localize(1597, 'Notebook Cell Completed'),
+        announcementMessage: localize(1601, 'Notebook Cell Completed'),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: localize(1598, 'Notebook Cell Failed'),
+        name: localize(1602, 'Notebook Cell Failed'),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: localize(1599, 'Notebook Cell Failed'),
+        announcementMessage: localize(1603, 'Notebook Cell Failed'),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: localize(1600, 'Diff Line Inserted'),
+        name: localize(1604, 'Diff Line Inserted'),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: localize(1601, 'Diff Line Deleted'),
+        name: localize(1605, 'Diff Line Deleted'),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: localize(1602, 'Diff Line Modified'),
+        name: localize(1606, 'Diff Line Modified'),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: localize(1603, 'Chat Edit Modified File'),
+        name: localize(1607, 'Chat Edit Modified File'),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: localize(1604, 'File Modified from Chat Edits'),
+        announcementMessage: localize(1608, 'File Modified from Chat Edits'),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: localize(1605, 'Chat Request Sent'),
+        name: localize(1609, 'Chat Request Sent'),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: localize(1606, 'Chat Request Sent'),
+        announcementMessage: localize(1610, 'Chat Request Sent'),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: localize(1607, 'Chat Response Received'),
+        name: localize(1611, 'Chat Response Received'),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -251,79 +251,79 @@ export class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: localize(1608, 'Code Action Request Triggered'),
+        name: localize(1612, 'Code Action Request Triggered'),
         sound: Sound.codeActionTriggered,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: localize(1609, 'Code Action Request Triggered'),
+        announcementMessage: localize(1613, 'Code Action Request Triggered'),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: localize(1610, 'Code Action Applied'),
+        name: localize(1614, 'Code Action Applied'),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.codeActionApplied,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: localize(1611, 'Progress'),
+        name: localize(1615, 'Progress'),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: localize(1612, 'Progress'),
+        announcementMessage: localize(1616, 'Progress'),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: localize(1613, 'Clear'),
+        name: localize(1617, 'Clear'),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: localize(1614, 'Clear'),
+        announcementMessage: localize(1618, 'Clear'),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: localize(1615, 'Save'),
+        name: localize(1619, 'Save'),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: localize(1616, 'Save'),
+        announcementMessage: localize(1620, 'Save'),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: localize(1617, 'Format'),
+        name: localize(1621, 'Format'),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: localize(1618, 'Format'),
+        announcementMessage: localize(1622, 'Format'),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: localize(1619, 'Voice Recording Started'),
+        name: localize(1623, 'Voice Recording Started'),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: localize(1620, 'Voice Recording Stopped'),
+        name: localize(1624, 'Voice Recording Stopped'),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
     static { this.editsKept = AccessibilitySignal.register({
-        name: localize(1621, 'Edits Kept'),
+        name: localize(1625, 'Edits Kept'),
         sound: Sound.editsKept,
-        announcementMessage: localize(1622, 'Edits Kept'),
+        announcementMessage: localize(1626, 'Edits Kept'),
         settingsKey: 'accessibility.signals.editsKept',
     }); }
     static { this.editsUndone = AccessibilitySignal.register({
-        name: localize(1623, 'Undo Edits'),
+        name: localize(1627, 'Undo Edits'),
         sound: Sound.editsUndone,
-        announcementMessage: localize(1624, 'Edits Undone'),
+        announcementMessage: localize(1628, 'Edits Undone'),
         settingsKey: 'accessibility.signals.editsUndone',
     }); }
     static { this.chatUserActionRequired = AccessibilitySignal.register({
-        name: localize(1625, 'Chat User Action Required'),
+        name: localize(1629, 'Chat User Action Required'),
         sound: Sound.chatUserActionRequired,
-        announcementMessage: localize(1626, 'Chat User Action Required'),
+        announcementMessage: localize(1630, 'Chat User Action Required'),
         settingsKey: 'accessibility.signals.chatUserActionRequired',
         managesOwnEnablement: true
     }); }

package/esm/vs/platform/action/common/actionCommonCategories.js

@@ -4,11 +4,11 @@
  *--------------------------------------------------------------------------------------------*/
 import { localize2 } from '../../../nls.js';
 export const Categories = Object.freeze({
-    View: localize2(1627, 'View'),
-    Help: localize2(1628, 'Help'),
-    Test: localize2(1629, 'Test'),
-    File: localize2(1630, 'File'),
-    Preferences: localize2(1631, 'Preferences'),
-    Developer: localize2(1632, "Developer"),
+    View: localize2(1631, 'View'),
+    Help: localize2(1632, 'Help'),
+    Test: localize2(1633, 'Test'),
+    File: localize2(1634, 'File'),
+    Preferences: localize2(1635, 'Preferences'),
+    Developer: localize2(1636, "Developer"),
 });
 //# sourceMappingURL=actionCommonCategories.js.map

package/esm/vs/platform/actionWidget/browser/actionList.js

@@ -119,10 +119,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = localize(1642, "{0} to Apply, {1} to Preview", actionTitle, previewTitle);
+                data.container.title = localize(1646, "{0} to Apply, {1} to Preview", actionTitle, previewTitle);
             }
             else {
-                data.container.title = localize(1643, "{0} to Apply", actionTitle);
+                data.container.title = localize(1647, "{0} to Apply", actionTitle);
             }
         }
         else {
@@ -191,13 +191,13 @@ let ActionList = class ActionList extends Disposable {
                             label = label + ', ' + stripNewlines(element.description);
                         }
                         if (element.disabled) {
-                            label = localize(1644, "{0}, Disabled Reason: {1}", label, element.disabled);
+                            label = localize(1648, "{0}, Disabled Reason: {1}", label, element.disabled);
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => localize(1645, "Action Widget"),
+                getWidgetAriaLabel: () => localize(1649, "Action Widget"),
                 getRole: (e) => {
                     switch (e.kind) {
                         case "action" /* ActionListItemKind.Action */: