@codingame/monaco-vscode-api 20.4.1 → 21.0.0

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

@@ -718,7 +718,7 @@ class NextWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(true, {
             id: 'editor.action.wordHighlight.next',
-            label: ( localize2(1643, "Go to Next Symbol Highlight")),
+            label: ( localize2(1645, "Go to Next Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -732,7 +732,7 @@ class PrevWordHighlightAction extends WordHighlightNavigationAction {
     constructor() {
         super(false, {
             id: 'editor.action.wordHighlight.prev',
-            label: ( localize2(1644, "Go to Previous Symbol Highlight")),
+            label: ( localize2(1646, "Go to Previous Symbol Highlight")),
             precondition: ctxHasWordHighlights,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -746,7 +746,7 @@ class TriggerWordHighlightAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.wordHighlight.trigger',
-            label: ( localize2(1645, "Trigger Symbol Highlight")),
+            label: ( localize2(1647, "Trigger Symbol Highlight")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,

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

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

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -103,6 +103,8 @@ import { IEnvironmentService } from '../../../platform/environment/common/enviro
 import { mainWindow } from '../../../base/browser/window.js';
 import { ITreeSitterLibraryService } from '../../common/services/treeSitter/treeSitterLibraryService.service.js';
 import { StandaloneTreeSitterLibraryService } from './standaloneTreeSitterLibraryService.js';
+import { NullDataChannelService } from '../../../platform/dataChannel/common/dataChannel.js';
+import { IDataChannelService } from '../../../platform/dataChannel/common/dataChannel.service.js';
 
 class SimpleModel {
     constructor(model) {
@@ -212,6 +214,7 @@ class StandaloneEnvironmentService {
         this.disableTelemetry = false;
         this.serviceMachineIdResource = ( URI.from({ scheme: 'monaco', authority: 'serviceMachineIdResource' }));
         this.policyFile = undefined;
+        this.isSimulation = undefined;
     }
 }
 class StandaloneDialogService {
@@ -955,6 +958,7 @@ registerSingleton(IMenuService, MenuService, InstantiationType.Eager);
 registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalService, InstantiationType.Eager);
 registerSingleton(ITreeSitterLibraryService, StandaloneTreeSitterLibraryService, InstantiationType.Eager);
 registerSingleton(ILoggerService, NullLoggerService, InstantiationType.Eager);
+registerSingleton(IDataChannelService, NullDataChannelService, InstantiationType.Eager);
 var StandaloneServices;
 (function (StandaloneServices) {
     const serviceCollection = ( new ServiceCollection());

package/vscode/src/vs/platform/accessibility/browser/accessibleView.d.ts

@@ -1,5 +1,5 @@
 import { IKeyboardEvent } from "../../keybinding/common/keybinding.js";
-import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
+import { IPickerQuickAccessItem } from "@codingame/monaco-vscode-23b6fb38-5e58-5886-b34b-27abc4f5df02-common/vscode/vs/platform/quickinput/browser/pickerQuickAccess";
 import { Event } from "../../../base/common/event.js";
 import { IAction } from "../../../base/common/actions.js";
 import { IQuickPickItem } from "../../quickinput/common/quickInput.js";

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

@@ -282,176 +282,176 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1647, 'Error at Position')),
+        name: ( localize(1649, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1648, 'Error')),
+        announcementMessage: ( localize(1650, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1649, 'Warning at Position')),
+        name: ( localize(1651, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1650, 'Warning')),
+        announcementMessage: ( localize(1652, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1651, 'Error on Line')),
+        name: ( localize(1653, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1652, 'Error on Line')),
+        announcementMessage: ( localize(1654, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1653, 'Warning on Line')),
+        name: ( localize(1655, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1654, 'Warning on Line')),
+        announcementMessage: ( localize(1656, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1655, 'Folded Area on Line')),
+        name: ( localize(1657, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1656, 'Folded')),
+        announcementMessage: ( localize(1658, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1657, 'Breakpoint on Line')),
+        name: ( localize(1659, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1658, 'Breakpoint')),
+        announcementMessage: ( localize(1660, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1659, 'Inline Suggestion on Line')),
+        name: ( localize(1661, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.nextEditSuggestion = AccessibilitySignal.register({
-        name: ( localize(1660, 'Next Edit Suggestion on Line')),
+        name: ( localize(1662, 'Next Edit Suggestion on Line')),
         sound: Sound.nextEditSuggestion,
         legacySoundSettingsKey: 'audioCues.nextEditSuggestion',
         settingsKey: 'accessibility.signals.nextEditSuggestion',
-        announcementMessage: ( localize(1661, 'Next Edit Suggestion')),
+        announcementMessage: ( localize(1663, 'Next Edit Suggestion')),
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1662, 'Terminal Quick Fix')),
+        name: ( localize(1664, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1663, 'Quick Fix')),
+        announcementMessage: ( localize(1665, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1664, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1666, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1665, 'Breakpoint')),
+        announcementMessage: ( localize(1667, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1666, 'No Inlay Hints on Line')),
+        name: ( localize(1668, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1667, 'No Inlay Hints')),
+        announcementMessage: ( localize(1669, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1668, 'Task Completed')),
+        name: ( localize(1670, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1669, 'Task Completed')),
+        announcementMessage: ( localize(1671, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1670, 'Task Failed')),
+        name: ( localize(1672, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1671, 'Task Failed')),
+        announcementMessage: ( localize(1673, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1672, 'Terminal Command Failed')),
+        name: ( localize(1674, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1673, 'Command Failed')),
+        announcementMessage: ( localize(1675, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1674, 'Terminal Command Succeeded')),
+        name: ( localize(1676, 'Terminal Command Succeeded')),
         sound: Sound.terminalCommandSucceeded,
-        announcementMessage: ( localize(1675, 'Command Succeeded')),
+        announcementMessage: ( localize(1677, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1676, 'Terminal Bell')),
+        name: ( localize(1678, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1677, 'Terminal Bell')),
+        announcementMessage: ( localize(1679, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1678, 'Notebook Cell Completed')),
+        name: ( localize(1680, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1679, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1681, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1680, 'Notebook Cell Failed')),
+        name: ( localize(1682, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1681, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1683, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1682, 'Diff Line Inserted')),
+        name: ( localize(1684, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1683, 'Diff Line Deleted')),
+        name: ( localize(1685, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1684, 'Diff Line Modified')),
+        name: ( localize(1686, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1685, 'Chat Edit Modified File')),
+        name: ( localize(1687, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1686, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1688, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1687, 'Chat Request Sent')),
+        name: ( localize(1689, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1688, 'Chat Request Sent')),
+        announcementMessage: ( localize(1690, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1689, 'Chat Response Received')),
+        name: ( localize(1691, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -464,79 +464,79 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1690, 'Code Action Request Triggered')),
+        name: ( localize(1692, 'Code Action Request Triggered')),
         sound: Sound.codeActionTriggered,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1691, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1693, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1692, 'Code Action Applied')),
+        name: ( localize(1694, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.codeActionApplied,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1693, 'Progress')),
+        name: ( localize(1695, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1694, 'Progress')),
+        announcementMessage: ( localize(1696, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1695, 'Clear')),
+        name: ( localize(1697, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1696, 'Clear')),
+        announcementMessage: ( localize(1698, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1697, 'Save')),
+        name: ( localize(1699, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1698, 'Save')),
+        announcementMessage: ( localize(1700, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1699, 'Format')),
+        name: ( localize(1701, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1700, 'Format')),
+        announcementMessage: ( localize(1702, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1701, 'Voice Recording Started')),
+        name: ( localize(1703, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1702, 'Voice Recording Stopped')),
+        name: ( localize(1704, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
     static { this.editsKept = AccessibilitySignal.register({
-        name: ( localize(1703, 'Edits Kept')),
+        name: ( localize(1705, 'Edits Kept')),
         sound: Sound.editsKept,
-        announcementMessage: ( localize(1704, 'Edits Kept')),
+        announcementMessage: ( localize(1706, 'Edits Kept')),
         settingsKey: 'accessibility.signals.editsKept',
     }); }
     static { this.editsUndone = AccessibilitySignal.register({
-        name: ( localize(1705, 'Undo Edits')),
+        name: ( localize(1707, 'Undo Edits')),
         sound: Sound.editsUndone,
-        announcementMessage: ( localize(1706, 'Edits Undone')),
+        announcementMessage: ( localize(1708, 'Edits Undone')),
         settingsKey: 'accessibility.signals.editsUndone',
     }); }
     static { this.chatUserActionRequired = AccessibilitySignal.register({
-        name: ( localize(1707, 'Chat User Action Required')),
+        name: ( localize(1709, 'Chat User Action Required')),
         sound: Sound.chatUserActionRequired,
-        announcementMessage: ( localize(1708, 'Chat User Action Required')),
+        announcementMessage: ( localize(1710, 'Chat User Action Required')),
         settingsKey: 'accessibility.signals.chatUserActionRequired',
         managesOwnEnablement: true
     }); }

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

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1709, 'View')),
-    Help: ( localize2(1710, 'Help')),
-    Test: ( localize2(1711, 'Test')),
-    File: ( localize2(1712, 'File')),
-    Preferences: ( localize2(1713, 'Preferences')),
-    Developer: ( localize2(1714, "Developer")),
+    View: ( localize2(1711, 'View')),
+    Help: ( localize2(1712, 'Help')),
+    Test: ( localize2(1713, 'Test')),
+    File: ( localize2(1714, 'File')),
+    Preferences: ( localize2(1715, 'Preferences')),
+    Developer: ( localize2(1716, "Developer")),
 }));
 
 export { Categories };

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

@@ -124,10 +124,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localize(1715, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+                data.container.title = ( localize(1717, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localize(1716, "{0} to Apply", actionTitle));
+                data.container.title = ( localize(1718, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -192,13 +192,13 @@ let ActionList = class ActionList extends Disposable {
                     if (element.kind === ActionListItemKind.Action) {
                         let label = element.label ? stripNewlines(element?.label) : '';
                         if (element.disabled) {
-                            label = ( localize(1717, "{0}, Disabled Reason: {1}", label, element.disabled));
+                            label = ( localize(1719, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localize(1718, "Action Widget")),
+                getWidgetAriaLabel: () => ( localize(1720, "Action Widget")),
                 getRole: (e) => {
                     switch (e.kind) {
                         case ActionListItemKind.Action:

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

@@ -29,9 +29,9 @@ import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
 registerCss(actionWidget);
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1719, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1721, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1720, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1722, "Whether the action widget list is visible"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -134,7 +134,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(1721, "Hide action widget")),
+            title: ( localize2(1723, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -151,7 +151,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(1722, "Select previous action")),
+            title: ( localize2(1724, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -172,7 +172,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(1723, "Select next action")),
+            title: ( localize2(1725, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -193,7 +193,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1724, "Accept selected action")),
+            title: ( localize2(1726, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -213,7 +213,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1725, "Preview selected action")),
+            title: ( localize2(1727, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,

package/vscode/src/vs/platform/actions/browser/floatingMenu.d.ts

@@ -16,7 +16,7 @@ export declare class FloatingClickWidget extends Widget {
 }
 export declare abstract class AbstractFloatingClickMenu extends Disposable {
     private readonly renderEmitter;
-    protected readonly onDidRender: import("../../../base/common/event.js").Event<FloatingClickWidget>;
+    protected get onDidRender(): import("../../../base/common/event.js").Event<FloatingClickWidget>;
     private readonly menu;
     constructor(menuId: MenuId, menuService: IMenuService, contextKeyService: IContextKeyService);
     /** Should be called in implementation constructors after they initialized */

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

@@ -45,10 +45,10 @@ class FloatingClickWidget extends Widget {
     }
 }
 let AbstractFloatingClickMenu = class AbstractFloatingClickMenu extends Disposable {
+    get onDidRender() { return this.renderEmitter.event; }
     constructor(menuId, menuService, contextKeyService) {
         super();
         this.renderEmitter = ( new Emitter());
-        this.onDidRender = this.renderEmitter.event;
         this.menu = this._register(menuService.createMenu(menuId, contextKeyService));
     }
     render() {

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.d.ts

@@ -38,18 +38,18 @@ export declare function fillInActionBarActions(groups: [
     Array<MenuItemAction | SubmenuItemAction>
 ][], target: IAction[] | PrimaryAndSecondaryActions, primaryGroup?: string | ((actionGroup: string) => boolean), shouldInlineSubmenu?: (action: SubmenuAction, group: string, groupSize: number) => boolean, useSeparatorsInPrimaryActions?: boolean): void;
 export interface IMenuEntryActionViewItemOptions {
-    draggable?: boolean;
-    keybinding?: string | null;
-    hoverDelegate?: IHoverDelegate;
-    keybindingNotRenderedWithLabel?: boolean;
+    readonly draggable?: boolean;
+    readonly keybinding?: string | null;
+    readonly hoverDelegate?: IHoverDelegate;
+    readonly keybindingNotRenderedWithLabel?: boolean;
 }
 export declare class MenuEntryActionViewItem<T extends IMenuEntryActionViewItemOptions = IMenuEntryActionViewItemOptions> extends ActionViewItem {
-    protected _options: T | undefined;
+    protected readonly _options: T | undefined;
     protected readonly _keybindingService: IKeybindingService;
-    protected _notificationService: INotificationService;
-    protected _contextKeyService: IContextKeyService;
-    protected _themeService: IThemeService;
-    protected _contextMenuService: IContextMenuService;
+    protected readonly _notificationService: INotificationService;
+    protected readonly _contextKeyService: IContextKeyService;
+    protected readonly _themeService: IThemeService;
+    protected readonly _contextMenuService: IContextMenuService;
     private readonly _accessibilityService;
     private _wantsAltCommand;
     private readonly _itemClassDispose;
@@ -65,8 +65,8 @@ export declare class MenuEntryActionViewItem<T extends IMenuEntryActionViewItemO
     private _updateItemClass;
 }
 export interface ITextOnlyMenuEntryActionViewItemOptions extends IMenuEntryActionViewItemOptions {
-    conversational?: boolean;
-    useComma?: boolean;
+    readonly conversational?: boolean;
+    readonly useComma?: boolean;
 }
 export declare class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem<ITextOnlyMenuEntryActionViewItemOptions> {
     render(container: HTMLElement): void;

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

@@ -188,17 +188,17 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localize(1728, "{0} ({1})", tooltip, keybindingLabel))
+            ? ( localize(1730, "{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(1728, "{0} ({1})", altTooltip, altKeybindingLabel))
+                ? ( localize(1730, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localize(
-                1729,
+                1731,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -274,10 +274,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1730, '{1} to {0}', this._action.label, kb2));
+                this.label.textContent = ( localize(1732, '{1} to {0}', this._action.label, kb2));
             }
             else {
-                this.label.textContent = ( localize(1731, '{0} ({1})', this._action.label, kb2));
+                this.label.textContent = ( localize(1733, '{0} ({1})', this._action.label, kb2));
             }
         }
     }

package/vscode/src/vs/platform/actions/browser/toolbar.d.ts

@@ -1,6 +1,5 @@
 import { IToolBarOptions, ToolBar } from "../../../base/browser/ui/toolbar/toolbar.js";
 import { IAction, SubmenuAction } from "../../../base/common/actions.js";
-import { Event } from "../../../base/common/event.js";
 import { IMenuActionOptions, MenuId } from "../common/actions.js";
 import { IMenuService } from "../common/actions.service.js";
 import { ICommandService } from "../../commands/common/commands.service.js";
@@ -88,10 +87,6 @@ export interface IToolBarRenderOptions {
      * Should the primary group allow for separators.
      */
     useSeparatorsInPrimaryActions?: boolean;
-    /**
-     * Force a leading separator in the primary actions group.
-     */
-    forceLeadingSeparatorInPrimaryActions?: boolean;
 }
 export interface IMenuWorkbenchToolBarOptions extends IWorkbenchToolBarOptions {
     /**
@@ -115,7 +110,7 @@ export interface IMenuWorkbenchToolBarOptions extends IWorkbenchToolBarOptions {
  */
 export declare class MenuWorkbenchToolBar extends WorkbenchToolBar {
     private readonly _onDidChangeMenuItems;
-    readonly onDidChangeMenuItems: Event<this>;
+    get onDidChangeMenuItems(): import("../../../base/common/event.js").Event<this>;
     constructor(container: HTMLElement, menuId: MenuId, options: IMenuWorkbenchToolBarOptions | undefined, menuService: IMenuService, contextKeyService: IContextKeyService, contextMenuService: IContextMenuService, keybindingService: IKeybindingService, commandService: ICommandService, telemetryService: ITelemetryService, actionViewService: IActionViewItemService, instaService: IInstantiationService);
     /**
      * @deprecated The WorkbenchToolBar does not support this method because it works with menus.