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

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

@@ -68,176 +68,176 @@ 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: [
@@ -250,79 +250,79 @@ 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

@@ -5,12 +5,12 @@ import { localize2 } from '../../../nls.js';
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 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"),
 });
 
 export { Categories };

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

@@ -126,10 +126,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 {
@@ -198,13 +198,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 */:

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

@@ -30,9 +30,9 @@ var __decorate = (undefined && undefined.__decorate) || function (decorators, ta
 var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, localize(1646, 'Background color for toggled action items in action bar.'));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, localize(1650, 'Background color for toggled action items in action bar.'));
 const ActionWidgetContextKeys = {
-    Visible: new RawContextKey('codeActionMenuVisible', false, localize(1647, "Whether the action widget list is visible"))
+    Visible: new RawContextKey('codeActionMenuVisible', false, localize(1651, "Whether the action widget list is visible"))
 };
 const IActionWidgetService = createDecorator('actionWidgetService');
 let ActionWidgetService = class ActionWidgetService extends Disposable {
@@ -138,7 +138,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: localize2(1648, "Hide action widget"),
+            title: localize2(1652, "Hide action widget"),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -155,7 +155,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: localize2(1649, "Select previous action"),
+            title: localize2(1653, "Select previous action"),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -176,7 +176,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: localize2(1650, "Select next action"),
+            title: localize2(1654, "Select next action"),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -197,7 +197,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: localize2(1651, "Accept selected action"),
+            title: localize2(1655, "Accept selected action"),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -217,7 +217,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: localize2(1652, "Preview selected action"),
+            title: localize2(1656, "Preview selected action"),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/esm/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -195,16 +195,16 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? localize(1633, "{0} ({1})", tooltip, keybindingLabel)
+            ? localize(1637, "{0} ({1})", tooltip, keybindingLabel)
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? localize(1634, "{0} ({1})", altTooltip, altKeybindingLabel)
+                ? localize(1638, "{0} ({1})", altTooltip, altKeybindingLabel)
                 : altTooltip;
-            title = localize(1635, "{0}\n[{1}] {2}", title, UILabelProvider.modifierLabels[OS].altKey, altTitleSection);
+            title = localize(1639, "{0}\n[{1}] {2}", title, UILabelProvider.modifierLabels[OS].altKey, altTitleSection);
         }
         return title;
     }
@@ -278,10 +278,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = localize(1636, '{1} to {0}', this._action.label, kb2);
+                this.label.textContent = localize(1640, '{1} to {0}', this._action.label, kb2);
             }
             else {
-                this.label.textContent = localize(1637, '{0} ({1})', this._action.label, kb2);
+                this.label.textContent = localize(1641, '{0} ({1})', this._action.label, kb2);
             }
         }
     }

package/esm/vs/platform/actions/browser/toolbar.js

@@ -174,7 +174,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     else {
                         primaryActions.push(toAction({
                             id: 'label',
-                            label: localize(1638, "Hide"),
+                            label: localize(1642, "Hide"),
                             enabled: false,
                             run() { }
                         }));
@@ -189,7 +189,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(new Separator());
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: localize(1639, "Reset Menu"),
+                        label: localize(1643, "Reset Menu"),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/esm/vs/platform/actions/common/menuService.js

@@ -403,7 +403,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: localize(1640, 'Hide \'{0}\'', title),
+        label: localize(1644, 'Hide \'{0}\'', title),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -421,7 +421,7 @@ function createMenuHide(menu, command, states) {
 function createConfigureKeybindingAction(commandService, keybindingService, commandId, when = undefined, enabled = true) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: localize(1641, "Configure Keybinding"),
+        label: localize(1645, "Configure Keybinding"),
         enabled,
         run() {
             // Only set the when clause when there is no keybinding

package/esm/vs/platform/configuration/common/configurationRegistry.js

@@ -26,7 +26,7 @@ class ConfigurationRegistry extends Disposable {
         this.configurationDefaultsOverrides = new Map();
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: localize(1653, "Default Language Configuration Overrides"),
+            title: localize(1657, "Default Language Configuration Overrides"),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -101,7 +101,7 @@ class ConfigurationRegistry extends Disposable {
         const property = {
             type: 'object',
             default: newDefaultOverride.value,
-            description: localize(1654, "Configure settings to be overridden for {0}.", getLanguageTagSettingPlainKey(key)),
+            description: localize(1658, "Configure settings to be overridden for {0}.", getLanguageTagSettingPlainKey(key)),
             $ref: resourceLanguageSettingsSchemaId,
             defaultDefaultValue: newDefaultOverride.value,
             source,
@@ -294,8 +294,8 @@ class ConfigurationRegistry extends Disposable {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: localize(1655, "Configure editor settings to be overridden for a language."),
-                errorMessage: localize(1656, "This setting does not support per-language configuration."),
+                description: localize(1659, "Configure editor settings to be overridden for a language."),
+                errorMessage: localize(1660, "This setting does not support per-language configuration."),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -303,8 +303,8 @@ class ConfigurationRegistry extends Disposable {
     }
     registerOverridePropertyPatternKey() {
         ({
-            description: localize(1657, "Configure editor settings to be overridden for a language."),
-            errorMessage: localize(1658, "This setting does not support per-language configuration.")});
+            description: localize(1661, "Configure editor settings to be overridden for a language."),
+            errorMessage: localize(1662, "This setting does not support per-language configuration.")});
         this._onDidSchemaChange.fire();
     }
     updatePropertyDefaultValue(key, property) {
@@ -368,16 +368,16 @@ const configurationRegistry = new ConfigurationRegistry();
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return localize(1659, "Cannot register an empty property");
+        return localize(1663, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
-        return localize(1660, "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.", property);
+        return localize(1664, "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.", property);
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
-        return localize(1661, "Cannot register '{0}'. This property is already registered.", property);
+        return localize(1665, "Cannot register '{0}'. This property is already registered.", property);
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
-        return localize(1662, "Cannot register '{0}'. The associated policy {1} is already registered with {2}.", property, schema.policy?.name, configurationRegistry.getPolicyConfigurations().get(schema.policy?.name));
+        return localize(1666, "Cannot register '{0}'. The associated policy {1} is already registered with {2}.", property, schema.policy?.name, configurationRegistry.getPolicyConfigurations().get(schema.policy?.name));
     }
     return null;
 }

package/esm/vs/platform/contextkey/browser/contextKeyService.js

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

package/esm/vs/platform/contextkey/common/contextkey.js

@@ -24,14 +24,14 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = localize(1664, "Empty context key expression");
-const hintEmptyString = localize(1665, "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively.");
-const errorNoInAfterNot = localize(1666, "'in' after 'not'.");
-const errorClosingParenthesis = localize(1667, "closing parenthesis ')'");
-const errorUnexpectedToken = localize(1668, "Unexpected token");
-const hintUnexpectedToken = localize(1669, "Did you forget to put && or || before the token?");
-const errorUnexpectedEOF = localize(1670, "Unexpected end of expression");
-const hintUnexpectedEOF = localize(1671, "Did you forget to put a context key?");
+const errorEmptyString = localize(1668, "Empty context key expression");
+const hintEmptyString = localize(1669, "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively.");
+const errorNoInAfterNot = localize(1670, "'in' after 'not'.");
+const errorClosingParenthesis = localize(1671, "closing parenthesis ')'");
+const errorUnexpectedToken = localize(1672, "Unexpected token");
+const hintUnexpectedToken = localize(1673, "Did you forget to put && or || before the token?");
+const errorUnexpectedEOF = localize(1674, "Unexpected end of expression");
+const hintUnexpectedEOF = localize(1675, "Did you forget to put a context key?");
 /**
  * A parser for context key expressions.
  *
@@ -376,7 +376,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = localize(1672, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got));
+        const message = localize(1676, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });

package/esm/vs/platform/contextkey/common/contextkeys.js

@@ -6,16 +6,16 @@ import { RawContextKey } from './contextkey.js';
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-new RawContextKey('isMac', isMacintosh, localize(1673, "Whether the operating system is macOS"));
-new RawContextKey('isLinux', isLinux, localize(1674, "Whether the operating system is Linux"));
-const IsWindowsContext = new RawContextKey('isWindows', isWindows, localize(1675, "Whether the operating system is Windows"));
-const IsWebContext = new RawContextKey('isWeb', isWeb, localize(1676, "Whether the platform is a web browser"));
-new RawContextKey('isMacNative', isMacintosh && !isWeb, localize(1677, "Whether the operating system is macOS on a non-browser platform"));
-new RawContextKey('isIOS', isIOS, localize(1678, "Whether the operating system is iOS"));
-new RawContextKey('isMobile', isMobile, localize(1679, "Whether the platform is a mobile web browser"));
+new RawContextKey('isMac', isMacintosh, localize(1677, "Whether the operating system is macOS"));
+new RawContextKey('isLinux', isLinux, localize(1678, "Whether the operating system is Linux"));
+const IsWindowsContext = new RawContextKey('isWindows', isWindows, localize(1679, "Whether the operating system is Windows"));
+const IsWebContext = new RawContextKey('isWeb', isWeb, localize(1680, "Whether the platform is a web browser"));
+new RawContextKey('isMacNative', isMacintosh && !isWeb, localize(1681, "Whether the operating system is macOS on a non-browser platform"));
+new RawContextKey('isIOS', isIOS, localize(1682, "Whether the operating system is iOS"));
+new RawContextKey('isMobile', isMobile, localize(1683, "Whether the platform is a mobile web browser"));
 new RawContextKey('isDevelopment', false, true);
-new RawContextKey('productQualityType', '', localize(1680, "Quality type of VS Code"));
+new RawContextKey('productQualityType', '', localize(1684, "Quality type of VS Code"));
 const InputFocusedContextKey = 'inputFocus';
-const InputFocusedContext = new RawContextKey(InputFocusedContextKey, false, localize(1681, "Whether keyboard focus is inside an input box"));
+const InputFocusedContext = new RawContextKey(InputFocusedContextKey, false, localize(1685, "Whether keyboard focus is inside an input box"));
 
 export { InputFocusedContext, InputFocusedContextKey, IsWebContext, IsWindowsContext };