monaco-editor 0.56.0-dev-20260120 → 0.56.0-dev-20260121

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

@@ -1,4 +1,4 @@
-define("vs/tsMode-Co79Xo5K", ["exports", "./ts.worker-CArJhH03", "./editor-V-thM4Kh", "./workers-BGdHt1rb", "./monaco.contribution-BoVCpaaV"], (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-_1BH4dlp.js → typescript-f8pt88eA.js}

@@ -1,4 +1,4 @@
-define("vs/typescript-_1BH4dlp", ["exports", "./editor-V-thM4Kh"], (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-BGdHt1rb.js → workers-zrUx_2Gw.js}

@@ -1,4 +1,4 @@
-define("vs/workers-BGdHt1rb", ["exports", "./editor-V-thM4Kh", "./toggleHighContrast-3bUMPAmT"], (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-Cqh8dVgY.js → xml-CmSjtiR0.js}

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

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

@@ -1,4 +1,4 @@
-define("vs/yaml-D6-bhWv5", ["exports", "./editor-V-thM4Kh"], (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/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

@@ -1,10 +1,10 @@
 import './nativeEditContext.css';
 import { isFirefox } from '../../../../../base/browser/browser.js';
-import { getWindow, addDisposableListener, getActiveElement, getWindowId, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
+import { getWindow, addDisposableListener, getActiveElement, getWindowId } from '../../../../../base/browser/dom.js';
 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)));
@@ -196,8 +216,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this.domNode.domNode.blur();
         this.domNode.domNode.remove();
         this._imeTextArea.domNode.remove();
-        this._selectionAndControlBoundsUpdateDisposable?.dispose();
-        this._selectionAndControlBoundsUpdateDisposable = undefined;
         super.dispose();
     }
     setAriaOptions(options) {
@@ -262,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() {
@@ -435,17 +453,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         }
     }
     _updateSelectionAndControlBoundsAfterRender() {
-        if (this._selectionAndControlBoundsUpdateDisposable) {
-            return;
-        }
-        // Schedule this work after render so we avoid triggering a layout while still painting.
-        const targetWindow = getWindow(this.domNode.domNode);
-        this._selectionAndControlBoundsUpdateDisposable = scheduleAtNextAnimationFrame(targetWindow, () => {
-            this._selectionAndControlBoundsUpdateDisposable = undefined;
-            this._applySelectionAndControlBounds();
-        });
-    }
-    _applySelectionAndControlBounds() {
         const options = this._context.configuration.options;
         const contentLeft = options.get(165 /* EditorOption.layoutInfo */).contentLeft;
         const viewSelection = this._context.viewModel.coordinatesConverter.convertModelRangeToViewRange(this._primarySelection);

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

@@ -1,7 +1,6 @@
 import './textAreaEditContext.css';
 import { localize } from '../../../../../nls.js';
 import { isSafari, isFirefox, isChrome, isAndroid } from '../../../../../base/browser/browser.js';
-import { getWindow, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
 import { createFastDomNode } from '../../../../../base/browser/fastDomNode.js';
 import { OS, isMacintosh } from '../../../../../base/common/platform.js';
 import { isHighSurrogate } from '../../../../../base/common/strings.js';
@@ -99,7 +98,6 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         super(context);
         this._keybindingService = _keybindingService;
         this._instantiationService = _instantiationService;
-        this._scheduledRender = null;
         this._primaryCursorPosition = new Position(1, 1);
         this._primaryCursorVisibleRange = null;
         this._viewController = viewController;
@@ -207,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);
         }));
@@ -333,8 +335,6 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         this._textAreaInput.writeNativeTextAreaContent(reason);
     }
     dispose() {
-        this._scheduledRender?.dispose();
-        this._scheduledRender = null;
         super.dispose();
         this.textArea.domNode.remove();
         this.textAreaCover.domNode.remove();
@@ -536,18 +536,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
     }
     render(ctx) {
         this._textAreaInput.writeNativeTextAreaContent('render');
-        this._scheduleRender();
-    }
-    // Delay expensive DOM updates until the next animation frame to reduce reflow pressure.
-    _scheduleRender() {
-        if (this._scheduledRender) {
-            return;
-        }
-        const targetWindow = getWindow(this.textArea.domNode);
-        this._scheduledRender = scheduleAtNextAnimationFrame(targetWindow, () => {
-            this._scheduledRender = null;
-            this._render();
-        });
+        this._render();
     }
     _render() {
         if (this._visibleTextArea) {

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(() => {

package/esm/vs/editor/browser/dataTransfer.js

@@ -1,5 +1,5 @@
 import { DataTransfers } from '../../base/browser/dnd.js';
-import { VSDataTransfer, createStringDataTransferItem, UriList, createFileDataTransferItem } from '../../base/common/dataTransfer.js';
+import { createStringDataTransferItem, UriList, VSDataTransfer, createFileDataTransferItem } from '../../base/common/dataTransfer.js';
 import { Mimes } from '../../base/common/mime.js';
 import { URI } from '../../base/common/uri.js';
 import { getPathForFile, CodeDataTransfers } from '../../platform/dnd/browser/dnd.js';

package/esm/vs/editor/browser/view.js

@@ -2,7 +2,7 @@ import { runAtThisOrScheduleAtNextAnimationFrame, getWindow, trackFocus } from '
 import { createFastDomNode } from '../../base/browser/fastDomNode.js';
 import { inputLatency } from '../../base/browser/performance.js';
 import { BugIndicatingError, onUnexpectedError } from '../../base/common/errors.js';
-import { Disposable } from '../../base/common/lifecycle.js';
+import { DisposableStore, Disposable } from '../../base/common/lifecycle.js';
 import { PointerHandlerLastRenderData } from './controller/mouseTarget.js';
 import { PointerHandler } from './controller/pointerHandler.js';
 import { RenderingContext } from './view/renderingContext.js';
@@ -66,6 +66,14 @@ let View = class View extends ViewEventHandler {
     constructor(editorContainer, ownerID, commandDelegate, configuration, colorTheme, model, userInputEvents, overflowWidgetsDomNode, _instantiationService) {
         super();
         this._instantiationService = _instantiationService;
+        this._editContextClipboardListeners = new DisposableStore();
+        // Clipboard events relayed from editContext
+        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;
         // Actual mutable state
         this._shouldRecomputeGlyphMarginLanes = false;
         this._ownerID = ownerID;
@@ -88,6 +96,7 @@ let View = class View extends ViewEventHandler {
         this._editContextEnabled = this._context.configuration.options.get(170 /* EditorOption.effectiveEditContext */);
         this._accessibilitySupport = this._context.configuration.options.get(2 /* EditorOption.accessibilitySupport */);
         this._editContext = this._instantiateEditContext();
+        this._connectEditContextClipboardEvents();
         this._viewParts.push(this._editContext);
         // These two dom nodes must be constructed up front, since references are needed in the layout provider (scrolling & co.)
         this._linesContent = createFastDomNode(document.createElement('div'));
@@ -211,6 +220,7 @@ let View = class View extends ViewEventHandler {
         const indexOfEditContext = this._viewParts.indexOf(this._editContext);
         this._editContext.dispose();
         this._editContext = this._instantiateEditContext();
+        this._connectEditContextClipboardEvents();
         if (isEditContextFocused) {
             this._editContext.focus();
         }
@@ -218,6 +228,14 @@ let View = class View extends ViewEventHandler {
             this._viewParts.splice(indexOfEditContext, 1, this._editContext);
         }
     }
+    _connectEditContextClipboardEvents() {
+        // Dispose old listeners
+        this._editContextClipboardListeners.clear();
+        // Connect to current edit context's clipboard events
+        this._editContextClipboardListeners.add(this._editContext.onWillCopy(e => this._onWillCopy.fire(e)));
+        this._editContextClipboardListeners.add(this._editContext.onWillCut(e => this._onWillCut.fire(e)));
+        this._editContextClipboardListeners.add(this._editContext.onWillPaste(e => this._onWillPaste.fire(e)));
+    }
     _computeGlyphMarginLanes() {
         const model = this._context.viewModel.model;
         const laneModel = this._context.viewModel.glyphLanes;
@@ -353,6 +371,8 @@ let View = class View extends ViewEventHandler {
             this._renderAnimationFrame.dispose();
             this._renderAnimationFrame = null;
         }
+        // Dispose clipboard event listeners
+        this._editContextClipboardListeners.dispose();
         this._contentWidgets.overflowingContentWidgetsDomNode.domNode.remove();
         this._overlayWidgets.overflowingOverlayWidgetsDomNode.domNode.remove();
         this._context.removeEventHandler(this);

package/esm/vs/editor/browser/widget/codeEditor/codeEditorWidget.js

@@ -134,6 +134,12 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
         this.onDidCompositionEnd = this._onDidCompositionEnd.event;
         this._onDidPaste = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
         this.onDidPaste = this._onDidPaste.event;
+        this._onWillCopy = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
+        this.onWillCopy = this._onWillCopy.event;
+        this._onWillCut = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
+        this.onWillCut = this._onWillCut.event;
+        this._onWillPaste = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
+        this.onWillPaste = this._onWillPaste.event;
         this._onMouseUp = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
         this.onMouseUp = this._onMouseUp.event;
         this._onMouseDown = this._register(new InteractionEmitter(this._contributions, this._deliveryQueue));
@@ -1240,6 +1246,14 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
             this._modelData.view.render(true, forceRedraw);
         });
     }
+    renderAsync(forceRedraw = false) {
+        if (!this._modelData || !this._modelData.hasRealView) {
+            return;
+        }
+        this._modelData.viewModel.batchEvents(() => {
+            this._modelData.view.render(false, forceRedraw);
+        });
+    }
     setAriaOptions(options) {
         if (!this._modelData || !this._modelData.hasRealView) {
             return;
@@ -1396,6 +1410,10 @@ let CodeEditorWidget = class CodeEditorWidget extends Disposable {
             }
             view.render(false, true);
             view.domNode.domNode.setAttribute('data-uri', model.uri.toString());
+            // Connect clipboard events from View
+            listenersToRemove.push(view.onWillCopy(e => this._onWillCopy.fire(e)));
+            listenersToRemove.push(view.onWillCut(e => this._onWillCut.fire(e)));
+            listenersToRemove.push(view.onWillPaste(e => this._onWillPaste.fire(e)));
         }
         this._modelData = new ModelData(model, viewModel, view, hasRealView, listenersToRemove, attachedView);
     }

package/esm/vs/editor/common/model/bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js

@@ -25,7 +25,7 @@ class ColorizedBracketPairsDecorationProvider extends Disposable {
         this.colorizationOptions = this.textModel.getOptions().bracketPairColorizationOptions;
     }
     //#endregion
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {
+    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations) {
         if (onlyMinimapDecorations) {
             // Bracket pair colorization decorations are not rendered in the minimap
             return [];
@@ -47,14 +47,14 @@ class ColorizedBracketPairsDecorationProvider extends Disposable {
         })).toArray();
         return result;
     }
-    getAllDecorations(ownerId, filterOutValidation) {
+    getAllDecorations(ownerId, filterOutValidation, filterFontDecorations) {
         if (ownerId === undefined) {
             return [];
         }
         if (!this.colorizationOptions.enabled) {
             return [];
         }
-        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), 1), ownerId, filterOutValidation);
+        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), 1), ownerId, filterOutValidation, filterFontDecorations);
     }
 }
 class ColorProvider {