@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/editor/standalone/browser/standaloneTreeSitterService.d.ts

@@ -1,7 +1,7 @@
 import type * as Parser from "@vscode/tree-sitter-wasm";
 import { Event } from "../../../base/common/event.js";
 import { ITextModel } from "../../common/model.js";
-import { ITextModelTreeSitter, ITreeSitterParseResult, TreeUpdateEvent } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
+import { ITextModelTreeSitter, TreeUpdateEvent } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
 import { ITreeSitterParserService } from "../../common/services/treeSitterParserService.service.js";
 export declare class StandaloneTreeSitterParserService implements ITreeSitterParserService {
     getLanguage(languageId: string): Promise<Parser.Language | undefined>;
@@ -15,5 +15,5 @@ export declare class StandaloneTreeSitterParserService implements ITreeSitterPar
         language: Parser.Language;
     }>;
     getOrInitLanguage(_languageId: string): Parser.Language | undefined;
-    getParseResult(textModel: ITextModel): ITreeSitterParseResult | undefined;
+    getParseResult(textModel: ITextModel): ITextModelTreeSitter | undefined;
 }

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

@@ -9,8 +9,10 @@ export declare enum AccessibleViewProviderId {
     TerminalChat = "terminal-chat",
     TerminalHelp = "terminal-help",
     DiffEditor = "diffEditor",
+    MergeEditor = "mergeEditor",
     PanelChat = "panelChat",
     InlineChat = "inlineChat",
+    AgentChat = "agentChat",
     QuickChat = "quickChat",
     InlineCompletions = "inlineCompletions",
     KeybindingsEditor = "keybindingsEditor",
@@ -86,6 +88,7 @@ export declare class AccessibleContentProvider extends Disposable implements IAc
     onDidRequestClearLastProvider?: Event<AccessibleViewProviderId> | undefined;
     constructor(id: AccessibleViewProviderId, options: IAccessibleViewOptions, provideContent: () => string, onClose: () => void, verbositySettingKey: string, onOpen?: (() => void) | undefined, actions?: IAction[] | undefined, provideNextContent?: (() => string | undefined) | undefined, providePreviousContent?: (() => string | undefined) | undefined, onDidChangeContent?: Event<void> | undefined, onKeyDown?: ((e: IKeyboardEvent) => void) | undefined, getSymbols?: (() => IAccessibleViewSymbol[]) | undefined, onDidRequestClearLastProvider?: Event<AccessibleViewProviderId> | undefined);
 }
+export declare function isIAccessibleViewContentProvider(obj: any): obj is IAccessibleViewContentProvider;
 export declare class ExtensionContentProvider extends Disposable implements IBasicContentProvider {
     readonly id: string;
     options: IAccessibleViewOptions;

package/vscode/src/vs/platform/accessibility/browser/accessibleView.js

@@ -7,8 +7,10 @@ var AccessibleViewProviderId;
     AccessibleViewProviderId["TerminalChat"] = "terminal-chat";
     AccessibleViewProviderId["TerminalHelp"] = "terminal-help";
     AccessibleViewProviderId["DiffEditor"] = "diffEditor";
+    AccessibleViewProviderId["MergeEditor"] = "mergeEditor";
     AccessibleViewProviderId["PanelChat"] = "panelChat";
     AccessibleViewProviderId["InlineChat"] = "inlineChat";
+    AccessibleViewProviderId["AgentChat"] = "agentChat";
     AccessibleViewProviderId["QuickChat"] = "quickChat";
     AccessibleViewProviderId["InlineCompletions"] = "inlineCompletions";
     AccessibleViewProviderId["KeybindingsEditor"] = "keybindingsEditor";
@@ -54,6 +56,9 @@ class AccessibleContentProvider extends Disposable {
         this.onDidRequestClearLastProvider = onDidRequestClearLastProvider;
     }
 }
+function isIAccessibleViewContentProvider(obj) {
+    return obj && obj.id && obj.options && obj.provideContent && obj.onClose && obj.verbositySettingKey;
+}
 class ExtensionContentProvider extends Disposable {
     constructor(id, options, provideContent, onClose, onOpen, provideNextContent, providePreviousContent, actions, onDidChangeContent) {
         super();
@@ -69,4 +74,4 @@ class ExtensionContentProvider extends Disposable {
     }
 }
 
-export { AccessibleContentProvider, AccessibleViewProviderId, AccessibleViewType, ExtensionContentProvider, NavigationType };
+export { AccessibleContentProvider, AccessibleViewProviderId, AccessibleViewType, ExtensionContentProvider, NavigationType, isIAccessibleViewContentProvider };

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.d.ts

@@ -66,6 +66,8 @@ export declare class Sound {
     static readonly voiceRecordingStopped: Sound;
     static readonly progress: Sound;
     static readonly chatEditModifiedFile: Sound;
+    static readonly editsKept: Sound;
+    static readonly editsUndone: Sound;
     private constructor();
 }
 export declare class SoundSource {
@@ -115,4 +117,6 @@ export declare class AccessibilitySignal {
     static readonly format: AccessibilitySignal;
     static readonly voiceRecordingStarted: AccessibilitySignal;
     static readonly voiceRecordingStopped: AccessibilitySignal;
+    static readonly editsKept: AccessibilitySignal;
+    static readonly editsUndone: AccessibilitySignal;
 }

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

@@ -215,6 +215,8 @@ class Sound {
     static { this.voiceRecordingStopped = Sound.register({ fileName: 'voiceRecordingStopped.mp3' }); }
     static { this.progress = Sound.register({ fileName: 'progress.mp3' }); }
     static { this.chatEditModifiedFile = Sound.register({ fileName: 'chatEditModifiedFile.mp3' }); }
+    static { this.editsKept = Sound.register({ fileName: 'editsKept.mp3' }); }
+    static { this.editsUndone = Sound.register({ fileName: 'editsUndone.mp3' }); }
     constructor(fileName) {
         this.fileName = fileName;
     }
@@ -262,169 +264,169 @@ class AccessibilitySignal {
         return [...this._signals];
     }
     static { this.errorAtPosition = AccessibilitySignal.register({
-        name: ( localize(1591, 'Error at Position')),
+        name: ( localize(1622, 'Error at Position')),
         sound: Sound.error,
-        announcementMessage: ( localize(1592, 'Error')),
+        announcementMessage: ( localize(1623, 'Error')),
         settingsKey: 'accessibility.signals.positionHasError',
         delaySettingsKey: 'accessibility.signalOptions.delays.errorAtPosition'
     }); }
     static { this.warningAtPosition = AccessibilitySignal.register({
-        name: ( localize(1593, 'Warning at Position')),
+        name: ( localize(1624, 'Warning at Position')),
         sound: Sound.warning,
-        announcementMessage: ( localize(1594, 'Warning')),
+        announcementMessage: ( localize(1625, 'Warning')),
         settingsKey: 'accessibility.signals.positionHasWarning',
         delaySettingsKey: 'accessibility.signalOptions.delays.warningAtPosition'
     }); }
     static { this.errorOnLine = AccessibilitySignal.register({
-        name: ( localize(1595, 'Error on Line')),
+        name: ( localize(1626, 'Error on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.lineHasError',
         legacyAnnouncementSettingsKey: 'accessibility.alert.error',
-        announcementMessage: ( localize(1596, 'Error on Line')),
+        announcementMessage: ( localize(1627, 'Error on Line')),
         settingsKey: 'accessibility.signals.lineHasError',
     }); }
     static { this.warningOnLine = AccessibilitySignal.register({
-        name: ( localize(1597, 'Warning on Line')),
+        name: ( localize(1628, 'Warning on Line')),
         sound: Sound.warning,
         legacySoundSettingsKey: 'audioCues.lineHasWarning',
         legacyAnnouncementSettingsKey: 'accessibility.alert.warning',
-        announcementMessage: ( localize(1598, 'Warning on Line')),
+        announcementMessage: ( localize(1629, 'Warning on Line')),
         settingsKey: 'accessibility.signals.lineHasWarning',
     }); }
     static { this.foldedArea = AccessibilitySignal.register({
-        name: ( localize(1599, 'Folded Area on Line')),
+        name: ( localize(1630, 'Folded Area on Line')),
         sound: Sound.foldedArea,
         legacySoundSettingsKey: 'audioCues.lineHasFoldedArea',
         legacyAnnouncementSettingsKey: 'accessibility.alert.foldedArea',
-        announcementMessage: ( localize(1600, 'Folded')),
+        announcementMessage: ( localize(1631, 'Folded')),
         settingsKey: 'accessibility.signals.lineHasFoldedArea',
     }); }
     static { this.break = AccessibilitySignal.register({
-        name: ( localize(1601, 'Breakpoint on Line')),
+        name: ( localize(1632, 'Breakpoint on Line')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.lineHasBreakpoint',
         legacyAnnouncementSettingsKey: 'accessibility.alert.breakpoint',
-        announcementMessage: ( localize(1602, 'Breakpoint')),
+        announcementMessage: ( localize(1633, 'Breakpoint')),
         settingsKey: 'accessibility.signals.lineHasBreakpoint',
     }); }
     static { this.inlineSuggestion = AccessibilitySignal.register({
-        name: ( localize(1603, 'Inline Suggestion on Line')),
+        name: ( localize(1634, 'Inline Suggestion on Line')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.lineHasInlineSuggestion',
         settingsKey: 'accessibility.signals.lineHasInlineSuggestion',
     }); }
     static { this.terminalQuickFix = AccessibilitySignal.register({
-        name: ( localize(1604, 'Terminal Quick Fix')),
+        name: ( localize(1635, 'Terminal Quick Fix')),
         sound: Sound.quickFixes,
         legacySoundSettingsKey: 'audioCues.terminalQuickFix',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalQuickFix',
-        announcementMessage: ( localize(1605, 'Quick Fix')),
+        announcementMessage: ( localize(1636, 'Quick Fix')),
         settingsKey: 'accessibility.signals.terminalQuickFix',
     }); }
     static { this.onDebugBreak = AccessibilitySignal.register({
-        name: ( localize(1606, 'Debugger Stopped on Breakpoint')),
+        name: ( localize(1637, 'Debugger Stopped on Breakpoint')),
         sound: Sound.break,
         legacySoundSettingsKey: 'audioCues.onDebugBreak',
         legacyAnnouncementSettingsKey: 'accessibility.alert.onDebugBreak',
-        announcementMessage: ( localize(1607, 'Breakpoint')),
+        announcementMessage: ( localize(1638, 'Breakpoint')),
         settingsKey: 'accessibility.signals.onDebugBreak',
     }); }
     static { this.noInlayHints = AccessibilitySignal.register({
-        name: ( localize(1608, 'No Inlay Hints on Line')),
+        name: ( localize(1639, 'No Inlay Hints on Line')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.noInlayHints',
         legacyAnnouncementSettingsKey: 'accessibility.alert.noInlayHints',
-        announcementMessage: ( localize(1609, 'No Inlay Hints')),
+        announcementMessage: ( localize(1640, 'No Inlay Hints')),
         settingsKey: 'accessibility.signals.noInlayHints',
     }); }
     static { this.taskCompleted = AccessibilitySignal.register({
-        name: ( localize(1610, 'Task Completed')),
+        name: ( localize(1641, 'Task Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.taskCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskCompleted',
-        announcementMessage: ( localize(1611, 'Task Completed')),
+        announcementMessage: ( localize(1642, 'Task Completed')),
         settingsKey: 'accessibility.signals.taskCompleted',
     }); }
     static { this.taskFailed = AccessibilitySignal.register({
-        name: ( localize(1612, 'Task Failed')),
+        name: ( localize(1643, 'Task Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.taskFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.taskFailed',
-        announcementMessage: ( localize(1613, 'Task Failed')),
+        announcementMessage: ( localize(1644, 'Task Failed')),
         settingsKey: 'accessibility.signals.taskFailed',
     }); }
     static { this.terminalCommandFailed = AccessibilitySignal.register({
-        name: ( localize(1614, 'Terminal Command Failed')),
+        name: ( localize(1645, 'Terminal Command Failed')),
         sound: Sound.error,
         legacySoundSettingsKey: 'audioCues.terminalCommandFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalCommandFailed',
-        announcementMessage: ( localize(1615, 'Command Failed')),
+        announcementMessage: ( localize(1646, 'Command Failed')),
         settingsKey: 'accessibility.signals.terminalCommandFailed',
     }); }
     static { this.terminalCommandSucceeded = AccessibilitySignal.register({
-        name: ( localize(1616, 'Terminal Command Succeeded')),
+        name: ( localize(1647, 'Terminal Command Succeeded')),
         sound: Sound.success,
-        announcementMessage: ( localize(1617, 'Command Succeeded')),
+        announcementMessage: ( localize(1648, 'Command Succeeded')),
         settingsKey: 'accessibility.signals.terminalCommandSucceeded',
     }); }
     static { this.terminalBell = AccessibilitySignal.register({
-        name: ( localize(1618, 'Terminal Bell')),
+        name: ( localize(1649, 'Terminal Bell')),
         sound: Sound.terminalBell,
         legacySoundSettingsKey: 'audioCues.terminalBell',
         legacyAnnouncementSettingsKey: 'accessibility.alert.terminalBell',
-        announcementMessage: ( localize(1619, 'Terminal Bell')),
+        announcementMessage: ( localize(1650, 'Terminal Bell')),
         settingsKey: 'accessibility.signals.terminalBell',
     }); }
     static { this.notebookCellCompleted = AccessibilitySignal.register({
-        name: ( localize(1620, 'Notebook Cell Completed')),
+        name: ( localize(1651, 'Notebook Cell Completed')),
         sound: Sound.taskCompleted,
         legacySoundSettingsKey: 'audioCues.notebookCellCompleted',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellCompleted',
-        announcementMessage: ( localize(1621, 'Notebook Cell Completed')),
+        announcementMessage: ( localize(1652, 'Notebook Cell Completed')),
         settingsKey: 'accessibility.signals.notebookCellCompleted',
     }); }
     static { this.notebookCellFailed = AccessibilitySignal.register({
-        name: ( localize(1622, 'Notebook Cell Failed')),
+        name: ( localize(1653, 'Notebook Cell Failed')),
         sound: Sound.taskFailed,
         legacySoundSettingsKey: 'audioCues.notebookCellFailed',
         legacyAnnouncementSettingsKey: 'accessibility.alert.notebookCellFailed',
-        announcementMessage: ( localize(1623, 'Notebook Cell Failed')),
+        announcementMessage: ( localize(1654, 'Notebook Cell Failed')),
         settingsKey: 'accessibility.signals.notebookCellFailed',
     }); }
     static { this.diffLineInserted = AccessibilitySignal.register({
-        name: ( localize(1624, 'Diff Line Inserted')),
+        name: ( localize(1655, 'Diff Line Inserted')),
         sound: Sound.diffLineInserted,
         legacySoundSettingsKey: 'audioCues.diffLineInserted',
         settingsKey: 'accessibility.signals.diffLineInserted',
     }); }
     static { this.diffLineDeleted = AccessibilitySignal.register({
-        name: ( localize(1625, 'Diff Line Deleted')),
+        name: ( localize(1656, 'Diff Line Deleted')),
         sound: Sound.diffLineDeleted,
         legacySoundSettingsKey: 'audioCues.diffLineDeleted',
         settingsKey: 'accessibility.signals.diffLineDeleted',
     }); }
     static { this.diffLineModified = AccessibilitySignal.register({
-        name: ( localize(1626, 'Diff Line Modified')),
+        name: ( localize(1657, 'Diff Line Modified')),
         sound: Sound.diffLineModified,
         legacySoundSettingsKey: 'audioCues.diffLineModified',
         settingsKey: 'accessibility.signals.diffLineModified',
     }); }
     static { this.chatEditModifiedFile = AccessibilitySignal.register({
-        name: ( localize(1627, 'Chat Edit Modified File')),
+        name: ( localize(1658, 'Chat Edit Modified File')),
         sound: Sound.chatEditModifiedFile,
-        announcementMessage: ( localize(1628, 'File Modified from Chat Edits')),
+        announcementMessage: ( localize(1659, 'File Modified from Chat Edits')),
         settingsKey: 'accessibility.signals.chatEditModifiedFile',
     }); }
     static { this.chatRequestSent = AccessibilitySignal.register({
-        name: ( localize(1629, 'Chat Request Sent')),
+        name: ( localize(1660, 'Chat Request Sent')),
         sound: Sound.requestSent,
         legacySoundSettingsKey: 'audioCues.chatRequestSent',
         legacyAnnouncementSettingsKey: 'accessibility.alert.chatRequestSent',
-        announcementMessage: ( localize(1630, 'Chat Request Sent')),
+        announcementMessage: ( localize(1661, 'Chat Request Sent')),
         settingsKey: 'accessibility.signals.chatRequestSent',
     }); }
     static { this.chatResponseReceived = AccessibilitySignal.register({
-        name: ( localize(1631, 'Chat Response Received')),
+        name: ( localize(1662, 'Chat Response Received')),
         legacySoundSettingsKey: 'audioCues.chatResponseReceived',
         sound: {
             randomOneOf: [
@@ -437,63 +439,75 @@ class AccessibilitySignal {
         settingsKey: 'accessibility.signals.chatResponseReceived'
     }); }
     static { this.codeActionTriggered = AccessibilitySignal.register({
-        name: ( localize(1632, 'Code Action Request Triggered')),
+        name: ( localize(1663, 'Code Action Request Triggered')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.codeActionRequestTriggered',
         legacyAnnouncementSettingsKey: 'accessibility.alert.codeActionRequestTriggered',
-        announcementMessage: ( localize(1633, 'Code Action Request Triggered')),
+        announcementMessage: ( localize(1664, 'Code Action Request Triggered')),
         settingsKey: 'accessibility.signals.codeActionTriggered',
     }); }
     static { this.codeActionApplied = AccessibilitySignal.register({
-        name: ( localize(1634, 'Code Action Applied')),
+        name: ( localize(1665, 'Code Action Applied')),
         legacySoundSettingsKey: 'audioCues.codeActionApplied',
         sound: Sound.voiceRecordingStopped,
         settingsKey: 'accessibility.signals.codeActionApplied'
     }); }
     static { this.progress = AccessibilitySignal.register({
-        name: ( localize(1635, 'Progress')),
+        name: ( localize(1666, 'Progress')),
         sound: Sound.progress,
         legacySoundSettingsKey: 'audioCues.chatResponsePending',
         legacyAnnouncementSettingsKey: 'accessibility.alert.progress',
-        announcementMessage: ( localize(1636, 'Progress')),
+        announcementMessage: ( localize(1667, 'Progress')),
         settingsKey: 'accessibility.signals.progress'
     }); }
     static { this.clear = AccessibilitySignal.register({
-        name: ( localize(1637, 'Clear')),
+        name: ( localize(1668, 'Clear')),
         sound: Sound.clear,
         legacySoundSettingsKey: 'audioCues.clear',
         legacyAnnouncementSettingsKey: 'accessibility.alert.clear',
-        announcementMessage: ( localize(1638, 'Clear')),
+        announcementMessage: ( localize(1669, 'Clear')),
         settingsKey: 'accessibility.signals.clear'
     }); }
     static { this.save = AccessibilitySignal.register({
-        name: ( localize(1639, 'Save')),
+        name: ( localize(1670, 'Save')),
         sound: Sound.save,
         legacySoundSettingsKey: 'audioCues.save',
         legacyAnnouncementSettingsKey: 'accessibility.alert.save',
-        announcementMessage: ( localize(1640, 'Save')),
+        announcementMessage: ( localize(1671, 'Save')),
         settingsKey: 'accessibility.signals.save'
     }); }
     static { this.format = AccessibilitySignal.register({
-        name: ( localize(1641, 'Format')),
+        name: ( localize(1672, 'Format')),
         sound: Sound.format,
         legacySoundSettingsKey: 'audioCues.format',
         legacyAnnouncementSettingsKey: 'accessibility.alert.format',
-        announcementMessage: ( localize(1642, 'Format')),
+        announcementMessage: ( localize(1673, 'Format')),
         settingsKey: 'accessibility.signals.format'
     }); }
     static { this.voiceRecordingStarted = AccessibilitySignal.register({
-        name: ( localize(1643, 'Voice Recording Started')),
+        name: ( localize(1674, 'Voice Recording Started')),
         sound: Sound.voiceRecordingStarted,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStarted',
         settingsKey: 'accessibility.signals.voiceRecordingStarted'
     }); }
     static { this.voiceRecordingStopped = AccessibilitySignal.register({
-        name: ( localize(1644, 'Voice Recording Stopped')),
+        name: ( localize(1675, 'Voice Recording Stopped')),
         sound: Sound.voiceRecordingStopped,
         legacySoundSettingsKey: 'audioCues.voiceRecordingStopped',
         settingsKey: 'accessibility.signals.voiceRecordingStopped'
     }); }
+    static { this.editsKept = AccessibilitySignal.register({
+        name: ( localize(1676, 'Edits Kept')),
+        sound: Sound.editsKept,
+        announcementMessage: ( localize(1677, 'Edits Kept')),
+        settingsKey: 'accessibility.signals.editsKept',
+    }); }
+    static { this.editsUndone = AccessibilitySignal.register({
+        name: ( localize(1678, 'Undo Edits')),
+        sound: Sound.editsUndone,
+        announcementMessage: ( localize(1679, 'Edits Undone')),
+        settingsKey: 'accessibility.signals.editsUndone',
+    }); }
 }
 
 export { AccessibilitySignal, AccessibilitySignalService, AcknowledgeDocCommentsToken, Sound, SoundSource };

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

@@ -2,12 +2,12 @@
 import { localize2 } from '../../../nls.js';
 
 const Categories = ( Object.freeze({
-    View: ( localize2(1645, 'View')),
-    Help: ( localize2(1646, 'Help')),
-    Test: ( localize2(1647, 'Test')),
-    File: ( localize2(1648, 'File')),
-    Preferences: ( localize2(1649, 'Preferences')),
-    Developer: ( localize2(1650, "Developer")),
+    View: ( localize2(1680, 'View')),
+    Help: ( localize2(1681, 'Help')),
+    Test: ( localize2(1682, 'Test')),
+    File: ( localize2(1683, 'File')),
+    Preferences: ( localize2(1684, 'Preferences')),
+    Developer: ( localize2(1685, "Developer")),
 }));
 
 export { Categories };

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

@@ -8,7 +8,7 @@ import { Codicon } from '../../../base/common/codicons.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { OS } from '../../../base/common/platform.js';
 import { ThemeIcon } from '../../../base/common/themables.js';
-import './actionWidget.css.js';
+import './actionWidget.css';
 import { localize } from '../../../nls.js';
 import { IContextViewService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
@@ -89,10 +89,10 @@ let ActionItemRenderer = class ActionItemRenderer {
         }
         else if (actionTitle && previewTitle) {
             if (this._supportsPreview && element.canPreview) {
-                data.container.title = ( localize(1651, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
+                data.container.title = ( localize(1686, "{0} to Apply, {1} to Preview", actionTitle, previewTitle));
             }
             else {
-                data.container.title = ( localize(1652, "{0} to Apply", actionTitle));
+                data.container.title = ( localize(1687, "{0} to Apply", actionTitle));
             }
         }
         else {
@@ -145,13 +145,13 @@ let ActionList = class ActionList extends Disposable {
                     if (element.kind === ActionListItemKind.Action) {
                         let label = element.label ? stripNewlines(element?.label) : '';
                         if (element.disabled) {
-                            label = ( localize(1653, "{0}, Disabled Reason: {1}", label, element.disabled));
+                            label = ( localize(1688, "{0}, Disabled Reason: {1}", label, element.disabled));
                         }
                         return label;
                     }
                     return null;
                 },
-                getWidgetAriaLabel: () => ( localize(1654, "Action Widget")),
+                getWidgetAriaLabel: () => ( localize(1689, "Action Widget")),
                 getRole: (e) => e.kind === ActionListItemKind.Action ? 'option' : 'separator',
                 getWidgetRole: () => 'listbox',
             },

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

@@ -0,0 +1,138 @@
+.action-widget {
+	font-size: 13px;
+	border-radius: 0;
+	min-width: 160px;
+	max-width: 80vw;
+	z-index: 40;
+	display: block;
+	width: 100%;
+	border: 1px solid var(--vscode-editorWidget-border) !important;
+	border-radius: 5px;
+	background-color: var(--vscode-editorActionList-background);
+	color: var(--vscode-editorActionList-foreground);
+	padding: 4px;
+	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
+}
+.context-view-block {
+	position: fixed;
+	cursor: initial;
+	left: 0;
+	top: 0;
+	width: 100%;
+	height: 100%;
+	z-index: -1;
+}
+.context-view-pointerBlock {
+	position: fixed;
+	cursor: initial;
+	left: 0;
+	top: 0;
+	width: 100%;
+	height: 100%;
+	z-index: 2;
+}
+.action-widget .monaco-list {
+	user-select: none;
+	-webkit-user-select: none;
+	border: none !important;
+	border-width: 0 !important;
+}
+.action-widget .monaco-list:focus:before {
+	outline: 0 !important;
+}
+.action-widget .monaco-list .monaco-scrollable-element {
+	overflow: visible;
+}
+.action-widget .monaco-list .monaco-list-row {
+	padding: 0 10px;
+	white-space: nowrap;
+	cursor: pointer;
+	touch-action: none;
+	width: 100%;
+	border-radius: 4px;
+}
+.action-widget .monaco-list .monaco-list-row.action.focused:not(.option-disabled) {
+	background-color: var(--vscode-editorActionList-focusBackground) !important;
+	color: var(--vscode-editorActionList-focusForeground);
+	outline: 1px solid var(--vscode-menu-selectionBorder, transparent);
+	outline-offset: -1px;
+}
+.action-widget .monaco-list-row.group-header {
+	color: var(--vscode-descriptionForeground) !important;
+	font-weight: 600;
+	font-size: 12px;
+}
+.action-widget .monaco-list-row.group-header:not(:first-of-type) {
+	margin-top: 2px;
+}
+.action-widget .monaco-list .group-header,
+.action-widget .monaco-list .option-disabled,
+.action-widget .monaco-list .option-disabled:before,
+.action-widget .monaco-list .option-disabled .focused,
+.action-widget .monaco-list .option-disabled .focused:before {
+	cursor: default !important;
+	-webkit-touch-callout: none;
+	-webkit-user-select: none;
+	user-select: none;
+	background-color: transparent !important;
+	outline: 0 solid !important;
+}
+.action-widget .monaco-list-row.action {
+	display: flex;
+	gap: 8px;
+	align-items: center;
+}
+.action-widget .monaco-list-row.action.option-disabled,
+.action-widget .monaco-list:focus .monaco-list-row.focused.action.option-disabled,
+.action-widget .monaco-list-row.action.option-disabled .codicon,
+.action-widget .monaco-list:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused).option-disabled {
+	color: var(--vscode-disabledForeground);
+}
+.action-widget .monaco-list-row.action:not(.option-disabled) .codicon {
+	color: inherit;
+}
+.action-widget .monaco-list-row.action .title {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+.action-widget .monaco-list-row.action .monaco-keybinding > .monaco-keybinding-key {
+		background-color: var(--vscode-keybindingLabel-background);
+		color: var(--vscode-keybindingLabel-foreground);
+		border-style: solid;
+		border-width: 1px;
+		border-radius: 3px;
+		border-color: var(--vscode-keybindingLabel-border);
+		border-bottom-color: var(--vscode-keybindingLabel-bottomBorder);
+		box-shadow: inset 0 -1px 0 var(--vscode-widget-shadow);
+}
+.action-widget .action-widget-action-bar {
+	background-color: var(--vscode-editorActionList-background);
+	border-top: 1px solid var(--vscode-editorHoverWidget-border);
+	margin-top: 2px;
+}
+.action-widget .action-widget-action-bar::before {
+	display: block;
+	content: "";
+	width: 100%;
+}
+.action-widget .action-widget-action-bar .actions-container {
+	padding: 3px 8px 0;
+}
+.action-widget-action-bar .action-label {
+	color: var(--vscode-textLink-activeForeground);
+	font-size: 12px;
+	line-height: 22px;
+	padding: 0;
+	pointer-events: all;
+}
+.action-widget-action-bar .action-item {
+	margin-right: 16px;
+	pointer-events: none;
+}
+.action-widget-action-bar .action-label:hover {
+	background-color: transparent !important;
+}
+.monaco-action-bar .actions-container.highlight-toggled .action-label.checked {
+	background: var(--vscode-actionBar-toggledBackground) !important;
+}

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

@@ -4,7 +4,7 @@ import { addDisposableListener, EventType, trackFocus, $ } from '../../../base/b
 import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
 import { KeyMod as KeyMod$1, KeyCode } from '../../../base/common/keyCodes.js';
 import { Disposable, MutableDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import './actionWidget.css.js';
+import './actionWidget.css';
 import { localize, localize2 } from '../../../nls.js';
 import { ActionList, acceptSelectedActionCommand, previewSelectedActionCommand } from './actionList.js';
 import { registerAction2, Action2 } from '../../actions/common/actions.js';
@@ -27,9 +27,9 @@ import '../../theme/common/colors/quickpickColors.js';
 import '../../theme/common/colors/searchColors.js';
 import { IActionWidgetService } from './actionWidget.service.js';
 
-registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1655, 'Background color for toggled action items in action bar.')));
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1690, 'Background color for toggled action items in action bar.')));
 const ActionWidgetContextKeys = {
-    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1656, "Whether the action widget list is visible"))))
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1691, "Whether the action widget list is visible"))))
 };
 let ActionWidgetService = class ActionWidgetService extends Disposable {
     get isVisible() {
@@ -132,7 +132,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'hideCodeActionWidget',
-            title: ( localize2(1657, "Hide action widget")),
+            title: ( localize2(1692, "Hide action widget")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -149,7 +149,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectPrevCodeAction',
-            title: ( localize2(1658, "Select previous action")),
+            title: ( localize2(1693, "Select previous action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -170,7 +170,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'selectNextCodeAction',
-            title: ( localize2(1659, "Select next action")),
+            title: ( localize2(1694, "Select next action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -191,7 +191,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: acceptSelectedActionCommand,
-            title: ( localize2(1660, "Accept selected action")),
+            title: ( localize2(1695, "Accept selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,
@@ -211,7 +211,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: previewSelectedActionCommand,
-            title: ( localize2(1661, "Preview selected action")),
+            title: ( localize2(1696, "Preview selected action")),
             precondition: ActionWidgetContextKeys.Visible,
             keybinding: {
                 weight,