monaco-editor 0.56.0-dev-20260119 → 0.56.0-dev-20260121

package/dev/vs/{tsMode-Dy3ckMs8.js → tsMode-jpkv3SbL.js}

@@ -1,4 +1,4 @@
-define("vs/tsMode-Dy3ckMs8", ["exports", "./ts.worker-CArJhH03", "./editor-ML6zs6Go", "./workers-B9Ao1ciR", "./monaco.contribution-t7Hz4wVA"], (function(exports, ts_worker, editor, workers, src_deprecated_language_typescript_monaco_contribution_ts) {
+define("vs/tsMode-jpkv3SbL", ["exports", "./ts.worker-CArJhH03", "./editor-CR18QzPP", "./workers-zrUx_2Gw", "./monaco.contribution-CVBrIlxn"], (function(exports, ts_worker, editor, workers, src_deprecated_language_typescript_monaco_contribution_ts) {
   "use strict";
   class WorkerManager {
     constructor(_modeId, _defaults) {

package/dev/vs/{typescript-BBL8N09V.js → typescript-f8pt88eA.js}

@@ -1,4 +1,4 @@
-define("vs/typescript-BBL8N09V", ["exports", "./editor-ML6zs6Go"], (function(exports, editor) {
+define("vs/typescript-f8pt88eA", ["exports", "./editor-CR18QzPP"], (function(exports, editor) {
   "use strict";
   const conf = {
     wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,

package/dev/vs/{workers-B9Ao1ciR.js → workers-zrUx_2Gw.js}

@@ -1,4 +1,4 @@
-define("vs/workers-B9Ao1ciR", ["exports", "./editor-ML6zs6Go", "./toggleHighContrast-Btd2ryZF"], (function(exports, editor, toggleHighContrast) {
+define("vs/workers-zrUx_2Gw", ["exports", "./editor-CR18QzPP", "./toggleHighContrast-CLgtrrIB"], (function(exports, editor, toggleHighContrast) {
   "use strict";
   function createTrustedTypesPolicy(policyName, policyOptions) {
     const monacoEnvironment = globalThis.MonacoEnvironment;

package/dev/vs/{xml-7BH7GgP4.js → xml-CmSjtiR0.js}

@@ -1,4 +1,4 @@
-define("vs/xml-7BH7GgP4", ["exports", "./editor-ML6zs6Go"], (function(exports, editor) {
+define("vs/xml-CmSjtiR0", ["exports", "./editor-CR18QzPP"], (function(exports, editor) {
   "use strict";
   const conf = {
     comments: {

package/dev/vs/{yaml-DvwGvgS8.js → yaml-PRriLGdw.js}

@@ -1,4 +1,4 @@
-define("vs/yaml-DvwGvgS8", ["exports", "./editor-ML6zs6Go"], (function(exports, editor) {
+define("vs/yaml-PRriLGdw", ["exports", "./editor-CR18QzPP"], (function(exports, editor) {
   "use strict";
   const conf = {
     comments: {

package/esm/vs/base/browser/markdownRenderer.js

@@ -498,6 +498,7 @@ function getDomSanitizerConfig(mdStrConfig, options) {
         Schemas.vscodeRemote,
         Schemas.vscodeRemoteResource,
         Schemas.vscodeNotebookCell,
+        Schemas.vscodeChatPrompt,
         // For links that are handled entirely by the action handler
         Schemas.internal,
     ];

package/esm/vs/base/browser/ui/actionbar/actionViewItems.js

@@ -283,7 +283,10 @@ class ActionViewItem extends BaseActionViewItem {
         if (this.cssClass && this.label) {
             this.label.classList.remove(...this.cssClass.split(' '));
         }
-        if (this.options.icon) {
+        if (this.action.id === Separator.ID && this.action.class) {
+            this.label?.classList.add(this.action.class);
+        }
+        else if (this.options.icon) {
             this.cssClass = this.getClass();
             if (this.label) {
                 this.label.classList.add('codicon');

package/esm/vs/base/browser/ui/actionbar/actionbar.css

@@ -45,7 +45,8 @@
 	height: 16px;
 }
 
-.monaco-action-bar .action-label {
+.monaco-action-bar .action-label,
+.monaco-action-bar .action-item .keybinding  {
 	display: flex;
 	font-size: 11px;
 	padding: 3px;
@@ -75,12 +76,14 @@
 	display: block;
 }
 
-.monaco-action-bar.vertical .action-label.separator {
+.monaco-action-bar.vertical .action-item .action-label.separator {
 	display: block;
-	border-bottom: 1px solid var(--vscode-disabledForeground);
+	border-bottom: 1px solid var(--vscode-menu-separatorBackground, var(--vscode-disabledForeground));
 	padding-top: 1px;
-	margin-left: .8em;
-	margin-right: .8em;
+	margin: 4px .8em;
+	width: 100%;
+	height: 0;
+	background-color: transparent;
 }
 
 .monaco-action-bar .action-item .action-label.separator {

package/esm/vs/base/browser/ui/contextview/contextview.js

@@ -39,7 +39,7 @@ function layout(viewportSize, viewSize, anchor) {
         if (viewSize <= layoutBeforeAnchorBoundary) {
             return layoutBeforeAnchorBoundary - viewSize; // happy case, lay it out before the anchor
         }
-        if (viewSize <= viewportSize - layoutAfterAnchorBoundary) {
+        if (viewSize <= viewportSize - layoutAfterAnchorBoundary && layoutBeforeAnchorBoundary < viewSize / 2) {
             return layoutAfterAnchorBoundary; // ok case, lay it out after the anchor
         }
         return 0; // sad case, lay it over the anchor

package/esm/vs/base/browser/ui/list/list.js

@@ -2,10 +2,11 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+const NotSelectableGroupId = 'notSelectable';
 class ListError extends Error {
     constructor(user, message) {
         super(`ListError [${user}] ${message}`);
     }
 }
 
-export { ListError };
+export { ListError, NotSelectableGroupId };

package/esm/vs/base/browser/ui/list/listWidget.js

@@ -17,7 +17,7 @@ import { clamp } from '../../../common/numbers.js';
 import { isMacintosh } from '../../../common/platform.js';
 import { isNumber } from '../../../common/types.js';
 import './list.css';
-import { ListError } from './list.js';
+import { ListError, NotSelectableGroupId } from './list.js';
 import { ListView } from './listView.js';
 import { StandardMouseEvent } from '../../mouseEvent.js';
 import '../../../common/observableInternal/index.js';
@@ -319,7 +319,14 @@ class KeyboardController {
     onCtrlA(e) {
         e.preventDefault();
         e.stopPropagation();
-        this.list.setSelection(range(this.list.length), e.browserEvent);
+        let selection = range(this.list.length);
+        // Filter by group if identity provider has getGroupId
+        const focusedElements = this.list.getFocus();
+        const referenceGroupId = focusedElements.length > 0 ? this.list.getElementGroupId(focusedElements[0]) : undefined;
+        if (referenceGroupId !== undefined) {
+            selection = this.list.filterIndicesByGroup(selection, referenceGroupId);
+        }
+        this.list.setSelection(selection, e.browserEvent);
         this.list.setAnchor(undefined);
         this.view.domNode.focus();
     }
@@ -614,7 +621,11 @@ class MouseController {
         this.list.setFocus([focus], e.browserEvent);
         this.list.setAnchor(focus);
         if (!isMouseRightClick(e.browserEvent)) {
-            this.list.setSelection([focus], e.browserEvent);
+            // Check if the element is selectable (getGroupId must not return undefined)
+            const focusGroupId = this.list.getElementGroupId(focus);
+            if (focusGroupId !== NotSelectableGroupId) {
+                this.list.setSelection([focus], e.browserEvent);
+            }
         }
         this._onPointer.fire(e);
     }
@@ -643,7 +654,14 @@ class MouseController {
             }
             const min = Math.min(anchor, focus);
             const max = Math.max(anchor, focus);
-            const rangeSelection = range(min, max + 1);
+            let rangeSelection = range(min, max + 1);
+            const selectedElement = this.list.getSelection()[0];
+            if (selectedElement !== undefined) {
+                const referenceGroupId = this.list.getElementGroupId(selectedElement);
+                if (referenceGroupId !== undefined) {
+                    rangeSelection = this.list.filterIndicesByGroup(rangeSelection, referenceGroupId);
+                }
+            }
             const selection = this.list.getSelection();
             const contiguousRange = getContiguousRangeContaining(disjunction(selection, [anchor]), anchor);
             if (contiguousRange.length === 0) {
@@ -658,8 +676,15 @@ class MouseController {
             const newSelection = selection.filter(i => i !== focus);
             this.list.setFocus([focus]);
             this.list.setAnchor(focus);
+            const focusGroupId = this.list.getElementGroupId(focus);
+            if (focusGroupId === NotSelectableGroupId) {
+                return; // Cannot select this element, do nothing
+            }
             if (selection.length === newSelection.length) {
-                this.list.setSelection([...newSelection, focus], e.browserEvent);
+                const itemsToBeSelected = focusGroupId !== undefined ?
+                    this.list.filterIndicesByGroup([...newSelection, focus], focusGroupId)
+                    : [...newSelection, focus];
+                this.list.setSelection(itemsToBeSelected, e.browserEvent);
             }
             else {
                 this.list.setSelection(newSelection, e.browserEvent);
@@ -1257,6 +1282,7 @@ class List {
                 throw new ListError(this.user, `Invalid index ${index}`);
             }
         }
+        indexes = indexes.filter(i => this.getElementGroupId(i) !== NotSelectableGroupId);
         this.selection.set(indexes, browserEvent);
     }
     getSelection() {
@@ -1282,6 +1308,37 @@ class List {
         const anchor = this.getAnchor();
         return typeof anchor === 'undefined' ? undefined : this.element(anchor);
     }
+    /**
+     * Gets the group ID for an element at the given index.
+     * Returns undefined if no identity provider, no getGroupId method, or if the group ID is undefined.
+     */
+    getElementGroupId(index) {
+        const identityProvider = this.options.identityProvider;
+        if (!identityProvider?.getGroupId) {
+            return undefined;
+        }
+        const element = this.element(index);
+        return identityProvider.getGroupId(element);
+    }
+    /**
+     * Filters the given indices to only include those with a matching group ID.
+     * If no identity provider or getGroupId method exists, returns the original indices.
+     * If referenceGroupId is undefined, returns an empty array (elements without group IDs are not selectable).
+     */
+    filterIndicesByGroup(indices, referenceGroupId) {
+        const identityProvider = this.options.identityProvider;
+        if (!identityProvider?.getGroupId) {
+            return indices;
+        }
+        if (referenceGroupId === NotSelectableGroupId) {
+            return [];
+        }
+        return indices.filter(index => {
+            const element = this.element(index);
+            const groupId = identityProvider.getGroupId(element);
+            return groupId === referenceGroupId;
+        });
+    }
     setFocus(indexes, browserEvent) {
         for (const index of indexes) {
             if (index < 0 || index >= this.length) {

package/esm/vs/base/browser/ui/tree/abstractTree.js

@@ -131,7 +131,10 @@ function asListOptions(modelProvider, disposableStore, options) {
         identityProvider: options.identityProvider && {
             getId(el) {
                 return options.identityProvider.getId(el.element);
-            }
+            },
+            getGroupId: options.identityProvider.getGroupId ? (el) => {
+                return options.identityProvider.getGroupId(el.element);
+            } : undefined
         },
         dnd: options.dnd && disposableStore.add(new TreeNodeListDragAndDrop(modelProvider, options.dnd)),
         multipleSelectionController: options.multipleSelectionController && {

package/esm/vs/base/browser/ui/tree/asyncDataTree.js

@@ -210,7 +210,10 @@ function asObjectTreeOptions(options) {
         identityProvider: options.identityProvider && {
             getId(el) {
                 return options.identityProvider.getId(el.element);
-            }
+            },
+            getGroupId: options.identityProvider.getGroupId ? (el) => {
+                return options.identityProvider.getGroupId(el.element);
+            } : undefined
         },
         dnd: options.dnd && new AsyncDataTreeNodeListDragAndDrop(options.dnd),
         multipleSelectionController: options.multipleSelectionController && {

package/esm/vs/editor/browser/controller/editContext/clipboardUtils.js

@@ -1,55 +1,42 @@
 import { isWindows } from '../../../../base/common/platform.js';
 import { Mimes } from '../../../../base/common/mime.js';
-import { LogLevel } from '../../../../platform/log/common/log.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
+import { toExternalVSDataTransfer } from '../../dataTransfer.js';
 
-function ensureClipboardGetsEditorSelection(e, context, logService, isFirefox) {
-    const viewModel = context.viewModel;
-    const options = context.configuration.options;
-    let id = undefined;
-    if (logService.getLevel() === LogLevel.Trace) {
-        id = generateUuid();
-    }
-    const { dataToCopy, storedMetadata } = generateDataToCopyAndStoreInMemory(viewModel, options, id, isFirefox);
-    // !!!!!
-    // This is a workaround for what we think is an Electron bug where
-    // execCommand('copy') does not always work (it does not fire a clipboard event)
-    // !!!!!
-    // We signal that we have executed a copy command
-    CopyOptions.electronBugWorkaroundCopyEventHasFired = true;
-    e.preventDefault();
-    if (e.clipboardData) {
-        ClipboardEventUtils.setTextData(e.clipboardData, dataToCopy.text, dataToCopy.html, storedMetadata);
-    }
-    logService.trace('ensureClipboardGetsEditorSelection with id : ', id, ' with text.length: ', dataToCopy.text.length);
+function generateDataToCopyAndStoreInMemory(viewModel, id, isFirefox) {
+    const { dataToCopy, metadata } = generateDataToCopy(viewModel);
+    storeMetadataInMemory(dataToCopy.text, metadata, isFirefox);
+    return { dataToCopy, metadata };
+}
+function storeMetadataInMemory(textToCopy, metadata, isFirefox) {
+    InMemoryClipboardMetadataManager.INSTANCE.set(
+    // When writing "LINE\r\n" to the clipboard and then pasting,
+    // Firefox pastes "LINE\n", so let's work around this quirk
+    (isFirefox ? textToCopy.replace(/\r\n/g, '\n') : textToCopy), metadata);
 }
-function generateDataToCopyAndStoreInMemory(viewModel, options, id, isFirefox) {
-    const emptySelectionClipboard = options.get(45 /* EditorOption.emptySelectionClipboard */);
-    const copyWithSyntaxHighlighting = options.get(31 /* EditorOption.copyWithSyntaxHighlighting */);
+function generateDataToCopy(viewModel) {
+    const emptySelectionClipboard = viewModel.getEditorOption(45 /* EditorOption.emptySelectionClipboard */);
+    const copyWithSyntaxHighlighting = viewModel.getEditorOption(31 /* EditorOption.copyWithSyntaxHighlighting */);
     const selections = viewModel.getCursorStates().map(cursorState => cursorState.modelState.selection);
     const dataToCopy = getDataToCopy(viewModel, selections, emptySelectionClipboard, copyWithSyntaxHighlighting);
-    const storedMetadata = {
+    const metadata = {
         version: 1,
-        id,
+        id: generateUuid(),
         isFromEmptySelection: dataToCopy.isFromEmptySelection,
         multicursorText: dataToCopy.multicursorText,
         mode: dataToCopy.mode
     };
-    InMemoryClipboardMetadataManager.INSTANCE.set(
-    // When writing "LINE\r\n" to the clipboard and then pasting,
-    // Firefox pastes "LINE\n", so let's work around this quirk
-    (isFirefox ? dataToCopy.text.replace(/\r\n/g, '\n') : dataToCopy.text), storedMetadata);
-    return { dataToCopy, storedMetadata };
+    return { dataToCopy, metadata };
 }
 function getDataToCopy(viewModel, modelSelections, emptySelectionClipboard, copyWithSyntaxHighlighting) {
-    const rawTextToCopy = viewModel.getPlainTextToCopy(modelSelections, emptySelectionClipboard, isWindows);
+    const { sourceRanges, sourceText } = viewModel.getPlainTextToCopy(modelSelections, emptySelectionClipboard, isWindows);
     const newLineCharacter = viewModel.model.getEOL();
     const isFromEmptySelection = (emptySelectionClipboard && modelSelections.length === 1 && modelSelections[0].isEmpty());
-    const multicursorText = (Array.isArray(rawTextToCopy) ? rawTextToCopy : null);
-    const text = (Array.isArray(rawTextToCopy) ? rawTextToCopy.join(newLineCharacter) : rawTextToCopy);
+    const multicursorText = (Array.isArray(sourceText) ? sourceText : null);
+    const text = (Array.isArray(sourceText) ? sourceText.join(newLineCharacter) : sourceText);
     let html = undefined;
     let mode = null;
-    if (CopyOptions.forceCopyWithSyntaxHighlighting || (copyWithSyntaxHighlighting && text.length < 65536)) {
+    if (CopyOptions.forceCopyWithSyntaxHighlighting || (copyWithSyntaxHighlighting && sourceText.length < 65536)) {
         const richText = viewModel.getRichTextToCopy(modelSelections, emptySelectionClipboard);
         if (richText) {
             html = richText.html;
@@ -58,6 +45,7 @@ function getDataToCopy(viewModel, modelSelections, emptySelectionClipboard, copy
     }
     const dataToCopy = {
         isFromEmptySelection,
+        sourceRanges,
         multicursorText,
         text,
         html,
@@ -122,5 +110,63 @@ const ClipboardEventUtils = {
         clipboardData.setData('vscode-editor-data', JSON.stringify(metadata));
     }
 };
+/**
+ * Creates an IClipboardCopyEvent from a DOM ClipboardEvent.
+ */
+function createClipboardCopyEvent(e, isCut, context, logService, isFirefox) {
+    const { dataToCopy, metadata } = generateDataToCopy(context.viewModel);
+    let handled = false;
+    return {
+        isCut,
+        clipboardData: {
+            setData: (type, value) => {
+                e.clipboardData?.setData(type, value);
+            },
+        },
+        dataToCopy,
+        ensureClipboardGetsEditorData: () => {
+            e.preventDefault();
+            if (e.clipboardData) {
+                ClipboardEventUtils.setTextData(e.clipboardData, dataToCopy.text, dataToCopy.html, metadata);
+            }
+            storeMetadataInMemory(dataToCopy.text, metadata, isFirefox);
+            logService.trace('ensureClipboardGetsEditorSelection with id : ', metadata.id, ' with text.length: ', dataToCopy.text.length);
+        },
+        setHandled: () => {
+            handled = true;
+            e.preventDefault();
+            e.stopImmediatePropagation();
+        },
+        get isHandled() { return handled; },
+    };
+}
+/**
+ * Creates an IClipboardPasteEvent from a DOM ClipboardEvent.
+ */
+function createClipboardPasteEvent(e) {
+    let handled = false;
+    let [text, metadata] = e.clipboardData ? ClipboardEventUtils.getTextData(e.clipboardData) : ['', null];
+    metadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
+    return {
+        clipboardData: createReadableClipboardData(e.clipboardData),
+        metadata,
+        text,
+        toExternalVSDataTransfer: () => e.clipboardData ? toExternalVSDataTransfer(e.clipboardData) : undefined,
+        browserEvent: e,
+        setHandled: () => {
+            handled = true;
+            e.preventDefault();
+            e.stopImmediatePropagation();
+        },
+        get isHandled() { return handled; },
+    };
+}
+function createReadableClipboardData(dataTransfer) {
+    return {
+        types: Array.from(dataTransfer?.types ?? []),
+        files: Array.prototype.slice.call(dataTransfer?.files ?? [], 0),
+        getData: (type) => dataTransfer?.getData(type) ?? '',
+    };
+}
 
-export { ClipboardEventUtils, CopyOptions, InMemoryClipboardMetadataManager, ensureClipboardGetsEditorSelection, generateDataToCopyAndStoreInMemory };
+export { CopyOptions, InMemoryClipboardMetadataManager, createClipboardCopyEvent, createClipboardPasteEvent, createReadableClipboardData, generateDataToCopyAndStoreInMemory };

package/esm/vs/editor/browser/controller/editContext/editContext.js

@@ -1,3 +1,4 @@
+import { Emitter } from '../../../../base/common/event.js';
 import { ViewPart } from '../../view/viewPart.js';
 
 /*---------------------------------------------------------------------------------------------
@@ -5,6 +6,16 @@ import { ViewPart } from '../../view/viewPart.js';
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 class AbstractEditContext extends ViewPart {
+    constructor() {
+        super(...arguments);
+        // Clipboard events - emitted before the default clipboard handling
+        this._onWillCopy = this._register(new Emitter());
+        this.onWillCopy = this._onWillCopy.event;
+        this._onWillCut = this._register(new Emitter());
+        this.onWillCut = this._onWillCut.event;
+        this._onWillPaste = this._register(new Emitter());
+        this.onWillPaste = this._onWillPaste.event;
+    }
 }
 
 export { AbstractEditContext };

package/esm/vs/editor/browser/controller/editContext/native/nativeEditContext.js

@@ -4,7 +4,7 @@ import { getWindow, addDisposableListener, getActiveElement, getWindowId } from
 import { FastDomNode } from '../../../../../base/browser/fastDomNode.js';
 import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
-import { ensureClipboardGetsEditorSelection, ClipboardEventUtils, InMemoryClipboardMetadataManager } from '../clipboardUtils.js';
+import { CopyOptions, createClipboardCopyEvent, createClipboardPasteEvent } from '../clipboardUtils.js';
 import { AbstractEditContext } from '../editContext.js';
 import { FocusTracker, editContextAddDisposableListener } from './nativeEditContextUtils.js';
 import { ScreenReaderSupport } from './screenReaderSupport.js';
@@ -81,14 +81,30 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._screenReaderSupport = this._register(instantiationService.createInstance(ScreenReaderSupport, this.domNode, context, this._viewController));
         this._register(addDisposableListener(this.domNode.domNode, 'copy', (e) => {
             this.logService.trace('NativeEditContext#copy');
-            ensureClipboardGetsEditorSelection(e, this._context, this.logService, isFirefox);
+            // !!!!!
+            // This is a workaround for what we think is an Electron bug where
+            // execCommand('copy') does not always work (it does not fire a clipboard event)
+            // !!!!!
+            // We signal that we have executed a copy command
+            CopyOptions.electronBugWorkaroundCopyEventHasFired = true;
+            const copyEvent = createClipboardCopyEvent(e, /* isCut */ false, this._context, this.logService, isFirefox);
+            this._onWillCopy.fire(copyEvent);
+            if (copyEvent.isHandled) {
+                return;
+            }
+            copyEvent.ensureClipboardGetsEditorData();
         }));
         this._register(addDisposableListener(this.domNode.domNode, 'cut', (e) => {
             this.logService.trace('NativeEditContext#cut');
+            const cutEvent = createClipboardCopyEvent(e, /* isCut */ true, this._context, this.logService, isFirefox);
+            this._onWillCut.fire(cutEvent);
+            if (cutEvent.isHandled) {
+                return;
+            }
             // Pretend here we touched the text area, as the `cut` event will most likely
             // result in a `selectionchange` event which we want to ignore
             this._screenReaderSupport.onWillCut();
-            ensureClipboardGetsEditorSelection(e, this._context, this.logService, isFirefox);
+            cutEvent.ensureClipboardGetsEditorData();
             this.logService.trace('NativeEditContext#cut (before viewController.cut)');
             this._viewController.cut();
         }));
@@ -107,28 +123,32 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         }));
         this._register(addDisposableListener(this.domNode.domNode, 'paste', (e) => {
             this.logService.trace('NativeEditContext#paste');
+            const pasteEvent = createClipboardPasteEvent(e);
+            this._onWillPaste.fire(pasteEvent);
+            if (pasteEvent.isHandled) {
+                e.preventDefault();
+                return;
+            }
             e.preventDefault();
             if (!e.clipboardData) {
                 return;
             }
-            let [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            this.logService.trace('NativeEditContext#paste with id : ', metadata?.id, ' with text.length: ', text.length);
-            if (!text) {
+            this.logService.trace('NativeEditContext#paste with id : ', pasteEvent.metadata?.id, ' with text.length: ', pasteEvent.text.length);
+            if (!pasteEvent.text) {
                 return;
             }
-            metadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
             let pasteOnNewLine = false;
             let multicursorText = null;
             let mode = null;
-            if (metadata) {
+            if (pasteEvent.metadata) {
                 const options = this._context.configuration.options;
                 const emptySelectionClipboard = options.get(45 /* EditorOption.emptySelectionClipboard */);
-                pasteOnNewLine = emptySelectionClipboard && !!metadata.isFromEmptySelection;
-                multicursorText = typeof metadata.multicursorText !== 'undefined' ? metadata.multicursorText : null;
-                mode = metadata.mode;
+                pasteOnNewLine = emptySelectionClipboard && !!pasteEvent.metadata.isFromEmptySelection;
+                multicursorText = typeof pasteEvent.metadata.multicursorText !== 'undefined' ? pasteEvent.metadata.multicursorText : null;
+                mode = pasteEvent.metadata.mode;
             }
             this.logService.trace('NativeEditContext#paste (before viewController.paste)');
-            this._viewController.paste(text, pasteOnNewLine, multicursorText, mode);
+            this._viewController.paste(pasteEvent.text, pasteOnNewLine, multicursorText, mode);
         }));
         // Edit context events
         this._register(editContextAddDisposableListener(this._editContext, 'textformatupdate', (e) => this._handleTextFormatUpdate(e)));
@@ -260,15 +280,15 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     onZonesChanged(e) {
         return true;
     }
-    onWillPaste() {
-        this.logService.trace('NativeEditContext#onWillPaste');
-        this._onWillPaste();
+    handleWillPaste() {
+        this.logService.trace('NativeEditContext#handleWillPaste');
+        this._prepareScreenReaderForPaste();
     }
-    _onWillPaste() {
+    _prepareScreenReaderForPaste() {
         this._screenReaderSupport.onWillPaste();
     }
-    onWillCopy() {
-        this.logService.trace('NativeEditContext#onWillCopy');
+    handleWillCopy() {
+        this.logService.trace('NativeEditContext#handleWillCopy');
         this.logService.trace('NativeEditContext#isFocused : ', this.domNode.domNode === getActiveElement());
     }
     writeScreenReaderContent() {

package/esm/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.js

@@ -205,6 +205,10 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
             isFirefox: isFirefox,
             isSafari: isSafari,
         }));
+        // Relay clipboard events from TextAreaInput
+        this._register(this._textAreaInput.onWillCopy(e => this._onWillCopy.fire(e)));
+        this._register(this._textAreaInput.onWillCut(e => this._onWillCut.fire(e)));
+        this._register(this._textAreaInput.onWillPaste(e => this._onWillPaste.fire(e)));
         this._register(this._textAreaInput.onKeyDown((e) => {
             this._viewController.emitKeyDown(e);
         }));

package/esm/vs/editor/browser/controller/editContext/textArea/textAreaEditContextInput.js

@@ -10,7 +10,7 @@ import { isHighSurrogate } from '../../../../../base/common/strings.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
 import { ILogService } from '../../../../../platform/log/common/log.js';
-import { InMemoryClipboardMetadataManager, ensureClipboardGetsEditorSelection, ClipboardEventUtils } from '../clipboardUtils.js';
+import { InMemoryClipboardMetadataManager, createClipboardCopyEvent, CopyOptions, createClipboardPasteEvent } from '../clipboardUtils.js';
 import { TextAreaState } from './textAreaEditContextState.js';
 
 /*---------------------------------------------------------------------------------------------
@@ -78,6 +78,12 @@ let TextAreaInput = class TextAreaInput extends Disposable {
         this.onCut = this._onCut.event;
         this._onPaste = this._register(new Emitter());
         this.onPaste = this._onPaste.event;
+        this._onWillCopy = this._register(new Emitter());
+        this.onWillCopy = this._onWillCopy.event;
+        this._onWillCut = this._register(new Emitter());
+        this.onWillCut = this._onWillCut.event;
+        this._onWillPaste = this._register(new Emitter());
+        this.onWillPaste = this._onWillPaste.event;
         this._onType = this._register(new Emitter());
         this.onType = this._onType.event;
         this._onCompositionStart = this._register(new Emitter());
@@ -238,40 +244,57 @@ let TextAreaInput = class TextAreaInput extends Disposable {
         // --- Clipboard operations
         this._register(this._textArea.onCut((e) => {
             this._logService.trace(`TextAreaInput#onCut`, e);
+            // Fire onWillCut event to allow interception
+            const cutEvent = createClipboardCopyEvent(e, /* isCut */ true, this._host.context, this._logService, this._browser.isFirefox);
+            this._onWillCut.fire(cutEvent);
+            if (cutEvent.isHandled) {
+                // Event was handled externally, skip default processing
+                return;
+            }
             // Pretend here we touched the text area, as the `cut` event will most likely
             // result in a `selectionchange` event which we want to ignore
             this._textArea.setIgnoreSelectionChangeTime('received cut event');
-            if (this._host.context) {
-                ensureClipboardGetsEditorSelection(e, this._host.context, this._logService, this._browser.isFirefox);
-            }
+            cutEvent.ensureClipboardGetsEditorData();
             this._asyncTriggerCut.schedule();
         }));
         this._register(this._textArea.onCopy((e) => {
             this._logService.trace(`TextAreaInput#onCopy`, e);
-            if (this._host.context) {
-                ensureClipboardGetsEditorSelection(e, this._host.context, this._logService, this._browser.isFirefox);
+            // !!!!!
+            // This is a workaround for what we think is an Electron bug where
+            // execCommand('copy') does not always work (it does not fire a clipboard event)
+            // !!!!!
+            // We signal that we have executed a copy command
+            CopyOptions.electronBugWorkaroundCopyEventHasFired = true;
+            // Fire onWillCopy event to allow interception
+            const copyEvent = createClipboardCopyEvent(e, /* isCut */ false, this._host.context, this._logService, this._browser.isFirefox);
+            this._onWillCopy.fire(copyEvent);
+            if (copyEvent.isHandled) {
+                // Event was handled externally, skip default processing
+                return;
             }
+            copyEvent.ensureClipboardGetsEditorData();
         }));
         this._register(this._textArea.onPaste((e) => {
             this._logService.trace(`TextAreaInput#onPaste`, e);
+            // Fire onWillPaste event to allow interception
+            const pasteEvent = createClipboardPasteEvent(e);
+            this._onWillPaste.fire(pasteEvent);
+            if (pasteEvent.isHandled) {
+                // Event was handled externally, skip default processing
+                return;
+            }
             // Pretend here we touched the text area, as the `paste` event will most likely
             // result in a `selectionchange` event which we want to ignore
             this._textArea.setIgnoreSelectionChangeTime('received paste event');
             e.preventDefault();
-            if (!e.clipboardData) {
-                return;
-            }
-            let [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            this._logService.trace(`TextAreaInput#onPaste with id : `, metadata?.id, ' with text.length: ', text.length);
-            if (!text) {
+            this._logService.trace(`TextAreaInput#onPaste with id : `, pasteEvent.metadata?.id, ' with text.length: ', pasteEvent.text.length);
+            if (!pasteEvent.text) {
                 return;
             }
-            // try the in-memory store
-            metadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
             this._logService.trace(`TextAreaInput#onPaste (before onPaste)`);
             this._onPaste.fire({
-                text: text,
-                metadata: metadata
+                text: pasteEvent.text,
+                metadata: pasteEvent.metadata
             });
         }));
         this._register(this._textArea.onFocus(() => {