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

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 {

package/esm/vs/editor/common/model/textModel.js

@@ -1351,15 +1351,15 @@ let TextModel = class TextModel extends Disposable {
         const endColumn = this.getLineMaxColumn(endLineNumber);
         const range = new Range(startLineNumber, 1, endLineNumber, endColumn);
         const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
-        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
-        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations));
         return decorations;
     }
     getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, filterFontDecorations = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
         const validatedRange = this.validateRange(range);
         const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMarginDecorations);
-        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
-        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
+        pushMany(decorations, this._fontTokenDecorationsProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations));
         return decorations;
     }
     getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false, filterFontDecorations = false) {
@@ -1369,7 +1369,9 @@ let TextModel = class TextModel extends Disposable {
         return this._decorationsTree.getAllInjectedText(this, ownerId);
     }
     getCustomLineHeightsDecorations(ownerId = 0) {
-        return this._decorationsTree.getAllCustomLineHeights(this, ownerId);
+        const decs = this._decorationsTree.getAllCustomLineHeights(this, ownerId);
+        pushMany(decs, this._fontTokenDecorationsProvider.getAllDecorations(ownerId));
+        return decs;
     }
     _getInjectedTextInLine(lineNumber) {
         const startOffset = this._buffer.getOffsetAt(lineNumber, 1);

package/esm/vs/editor/common/model/tokens/tokenizationFontDecorationsProvider.js

@@ -94,34 +94,38 @@ class TokenizationFontDecorationProvider extends Disposable {
         this._onDidChangeLineHeight.fire(affectedLineHeights);
         this._onDidChangeFont.fire(affectedLineFonts);
     }
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {
+    getDecorationsInRange(range, ownerId, filterOutValidation, filterFontDecorations, onlyMinimapDecorations) {
         const startOffsetOfRange = this.textModel.getOffsetAt(range.getStartPosition());
         const endOffsetOfRange = this.textModel.getOffsetAt(range.getEndPosition());
         const annotations = this._fontAnnotatedString.getAnnotationsIntersecting(new OffsetRange(startOffsetOfRange, endOffsetOfRange));
         const decorations = [];
         for (const annotation of annotations) {
-            const annotationStartPosition = this.textModel.getPositionAt(annotation.range.start);
-            const annotationEndPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
-            const range = Range.fromPositions(annotationStartPosition, annotationEndPosition);
             const anno = annotation.annotation;
-            const className = classNameForFontTokenDecorations(anno.fontToken.fontFamily ?? '', anno.fontToken.fontSizeMultiplier ?? 0);
             const affectsFont = !!(anno.fontToken.fontFamily || anno.fontToken.fontSizeMultiplier);
-            const id = anno.decorationId;
-            decorations.push({
-                id: id,
-                options: {
-                    description: 'FontOptionDecoration',
-                    inlineClassName: className,
-                    affectsFont
-                },
-                ownerId: 0,
-                range
-            });
+            if (!(affectsFont && filterFontDecorations)) {
+                const annotationStartPosition = this.textModel.getPositionAt(annotation.range.start);
+                const annotationEndPosition = this.textModel.getPositionAt(annotation.range.endExclusive);
+                const range = Range.fromPositions(annotationStartPosition, annotationEndPosition);
+                const anno = annotation.annotation;
+                const className = classNameForFontTokenDecorations(anno.fontToken.fontFamily ?? '', anno.fontToken.fontSizeMultiplier ?? 0);
+                const id = anno.decorationId;
+                decorations.push({
+                    id: id,
+                    options: {
+                        description: 'FontOptionDecoration',
+                        inlineClassName: className,
+                        lineHeight: anno.fontToken.lineHeightMultiplier,
+                        affectsFont
+                    },
+                    ownerId: 0,
+                    range
+                });
+            }
         }
         return decorations;
     }
     getAllDecorations(ownerId, filterOutValidation) {
-        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), 1), ownerId, filterOutValidation);
+        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), this.textModel.getLineMaxColumn(this.textModel.getLineCount())), ownerId, filterOutValidation);
     }
 }
 

package/esm/vs/editor/common/viewModel/viewModelDecorations.js

@@ -84,10 +84,11 @@ class ViewModelDecorations {
         const decorationsInViewport = [];
         let decorationsInViewportLen = 0;
         const inlineDecorations = [];
+        const hasVariableFonts = [];
         for (let j = startLineNumber; j <= endLineNumber; j++) {
             inlineDecorations[j - startLineNumber] = [];
+            hasVariableFonts[j - startLineNumber] = false;
         }
-        let hasVariableFonts = false;
         for (let i = 0, len = modelDecorations.length; i < len; i++) {
             const modelDecoration = modelDecorations[i];
             const decorationOptions = modelDecoration.options;
@@ -103,23 +104,29 @@ class ViewModelDecorations {
                 const intersectedEndLineNumber = Math.min(endLineNumber, viewRange.endLineNumber);
                 for (let j = intersectedStartLineNumber; j <= intersectedEndLineNumber; j++) {
                     inlineDecorations[j - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[j - startLineNumber] = true;
+                    }
                 }
             }
             if (decorationOptions.beforeContentClassName) {
                 if (startLineNumber <= viewRange.startLineNumber && viewRange.startLineNumber <= endLineNumber) {
                     const inlineDecoration = new InlineDecoration(new Range(viewRange.startLineNumber, viewRange.startColumn, viewRange.startLineNumber, viewRange.startColumn), decorationOptions.beforeContentClassName, 1 /* InlineDecorationType.Before */);
                     inlineDecorations[viewRange.startLineNumber - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[viewRange.startLineNumber - startLineNumber] = true;
+                    }
                 }
             }
             if (decorationOptions.afterContentClassName) {
                 if (startLineNumber <= viewRange.endLineNumber && viewRange.endLineNumber <= endLineNumber) {
                     const inlineDecoration = new InlineDecoration(new Range(viewRange.endLineNumber, viewRange.endColumn, viewRange.endLineNumber, viewRange.endColumn), decorationOptions.afterContentClassName, 2 /* InlineDecorationType.After */);
                     inlineDecorations[viewRange.endLineNumber - startLineNumber].push(inlineDecoration);
+                    if (decorationOptions.affectsFont) {
+                        hasVariableFonts[viewRange.endLineNumber - startLineNumber] = true;
+                    }
                 }
             }
-            if (decorationOptions.affectsFont) {
-                hasVariableFonts = true;
-            }
         }
         return {
             decorations: decorationsInViewport,

package/esm/vs/editor/common/viewModel/viewModelImpl.js

@@ -105,6 +105,9 @@ class ViewModel extends Disposable {
         this._viewportStart.dispose();
         this._eventDispatcher.dispose();
     }
+    getEditorOption(id) {
+        return this._configuration.options.get(id);
+    }
     createLineBreaksComputer() {
         return this._lines.createLineBreaksComputer();
     }
@@ -119,6 +122,7 @@ class ViewModel extends Disposable {
         if (!allowVariableLineHeights) {
             return [];
         }
+        const defaultLineHeight = this._configuration.options.get(75 /* EditorOption.lineHeight */);
         const decorations = this.model.getCustomLineHeightsDecorations(this._editorId);
         return decorations.map((d) => {
             const lineNumber = d.range.startLineNumber;
@@ -127,7 +131,7 @@ class ViewModel extends Disposable {
                 decorationId: d.id,
                 startLineNumber: viewRange.startLineNumber,
                 endLineNumber: viewRange.endLineNumber,
-                lineHeight: d.options.lineHeight || 0
+                lineHeight: d.options.lineHeight ? d.options.lineHeight * defaultLineHeight : 0
             };
         });
     }
@@ -665,12 +669,14 @@ class ViewModel extends Disposable {
     }
     getViewportViewLineRenderingData(visibleRange, lineNumber) {
         const viewportDecorationsCollection = this._decorations.getDecorationsViewportData(visibleRange);
-        const inlineDecorations = viewportDecorationsCollection.inlineDecorations[lineNumber - visibleRange.startLineNumber];
-        return this._getViewLineRenderingData(lineNumber, inlineDecorations, viewportDecorationsCollection.hasVariableFonts, viewportDecorationsCollection.decorations);
+        const relativeLineNumber = lineNumber - visibleRange.startLineNumber;
+        const inlineDecorations = viewportDecorationsCollection.inlineDecorations[relativeLineNumber];
+        const hasVariableFonts = viewportDecorationsCollection.hasVariableFonts[relativeLineNumber];
+        return this._getViewLineRenderingData(lineNumber, inlineDecorations, hasVariableFonts, viewportDecorationsCollection.decorations);
     }
     getViewLineRenderingData(lineNumber) {
         const decorationsCollection = this._decorations.getDecorationsOnLine(lineNumber);
-        return this._getViewLineRenderingData(lineNumber, decorationsCollection.inlineDecorations[0], decorationsCollection.hasVariableFonts, decorationsCollection.decorations);
+        return this._getViewLineRenderingData(lineNumber, decorationsCollection.inlineDecorations[0], decorationsCollection.hasVariableFonts[0], decorationsCollection.decorations);
     }
     _getViewLineRenderingData(lineNumber, inlineDecorations, hasVariableFonts, decorations) {
         const mightContainRTL = this.model.mightContainRTL();
@@ -765,33 +771,38 @@ class ViewModel extends Disposable {
         }
         if (!hasNonEmptyRange && !emptySelectionClipboard) {
             // all ranges are empty
-            return '';
+            return { sourceRanges: [], sourceText: '' };
         }
+        const ranges = [];
+        const result = [];
+        const pushRange = (modelRange, append = '') => {
+            ranges.push(modelRange);
+            result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */) + append);
+        };
         if (hasEmptyRange && emptySelectionClipboard) {
             // some (maybe all) empty selections
-            const result = [];
             let prevModelLineNumber = 0;
             for (const modelRange of modelRanges) {
                 const modelLineNumber = modelRange.startLineNumber;
                 if (modelRange.isEmpty()) {
                     if (modelLineNumber !== prevModelLineNumber) {
-                        result.push(this.model.getLineContent(modelLineNumber) + newLineCharacter);
+                        pushRange(new Range(modelLineNumber, this.model.getLineMinColumn(modelLineNumber), modelLineNumber, this.model.getLineMaxColumn(modelLineNumber)), newLineCharacter);
                     }
                 }
                 else {
-                    result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */));
+                    pushRange(modelRange);
                 }
                 prevModelLineNumber = modelLineNumber;
             }
-            return result.length === 1 ? result[0] : result;
         }
-        const result = [];
-        for (const modelRange of modelRanges) {
-            if (!modelRange.isEmpty()) {
-                result.push(this.model.getValueInRange(modelRange, forceCRLF ? 2 /* EndOfLinePreference.CRLF */ : 0 /* EndOfLinePreference.TextDefined */));
+        else {
+            for (const modelRange of modelRanges) {
+                if (!modelRange.isEmpty()) {
+                    pushRange(modelRange);
+                }
             }
         }
-        return result.length === 1 ? result[0] : result;
+        return { sourceRanges: ranges, sourceText: result.length === 1 ? result[0] : result };
     }
     getRichTextToCopy(modelRanges, emptySelectionClipboard) {
         const languageId = this.model.getLanguageId();

package/esm/vs/editor/contrib/clipboard/browser/clipboard.js

@@ -180,7 +180,7 @@ function executeClipboardCopyWithWorkaround(editor, clipboardService) {
         // We have encountered the Electron bug!
         // As a workaround, we will write (only the plaintext data) to the clipboard in a different way
         // We will use the clipboard service (which in the native case will go to electron's clipboard API)
-        const { dataToCopy } = generateDataToCopyAndStoreInMemory(editor._getViewModel(), editor.getOptions(), undefined, isFirefox);
+        const { dataToCopy } = generateDataToCopyAndStoreInMemory(editor._getViewModel(), undefined, isFirefox);
         clipboardService.writeText(dataToCopy.text);
     }
 }
@@ -241,7 +241,7 @@ function logCopyCommand(editor) {
     if (editContextEnabled) {
         const nativeEditContext = NativeEditContextRegistry.get(editor.getId());
         if (nativeEditContext) {
-            nativeEditContext.onWillCopy();
+            nativeEditContext.handleWillCopy();
         }
     }
 }
@@ -262,7 +262,7 @@ if (PasteAction) {
             if (editContextEnabled) {
                 const nativeEditContext = NativeEditContextRegistry.get(focusedEditor.getId());
                 if (nativeEditContext) {
-                    nativeEditContext.onWillPaste();
+                    nativeEditContext.handleWillPaste();
                 }
             }
             logService.trace('registerExecCommandImpl (before triggerPaste)');

package/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController.js

@@ -1,13 +1,11 @@
-import { addDisposableListener } from '../../../../base/browser/dom.js';
 import { coalesce } from '../../../../base/common/arrays.js';
 import { createCancelablePromise, DeferredPromise, raceCancellation } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
+import { VSDataTransfer, matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
 import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { Mimes } from '../../../../base/common/mime.js';
-import { isWindows } from '../../../../base/common/platform.js';
 import { upcast } from '../../../../base/common/types.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { localize } from '../../../../nls.js';
@@ -19,10 +17,7 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { ILogService } from '../../../../platform/log/common/log.js';
 import { IProgressService } from '../../../../platform/progress/common/progress.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { ClipboardEventUtils, InMemoryClipboardMetadataManager } from '../../../browser/controller/editContext/clipboardUtils.js';
-import { toVSDataTransfer, toExternalVSDataTransfer } from '../../../browser/dataTransfer.js';
 import { IBulkEditService } from '../../../browser/services/bulkEditService.js';
-import { Range } from '../../../common/core/range.js';
 import { DocumentPasteTriggerKind } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { EditorStateCancellationTokenSource } from '../../editorState/browser/editorState.js';
@@ -67,10 +62,9 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         this._quickInputService = _quickInputService;
         this._progressService = _progressService;
         this._editor = editor;
-        const container = editor.getContainerDomNode();
-        this._register(addDisposableListener(container, 'copy', e => this.handleCopy(e)));
-        this._register(addDisposableListener(container, 'cut', e => this.handleCopy(e)));
-        this._register(addDisposableListener(container, 'paste', e => this.handlePaste(e), true));
+        this._register(editor.onWillCopy(e => this.handleCopy(e)));
+        this._register(editor.onWillCut(e => this.handleCopy(e)));
+        this._register(editor.onWillPaste(e => this.handlePaste(e)));
         this._pasteProgressManager = this._register(new InlineProgressManager('pasteIntoEditor', editor, instantiationService));
         this._postPasteWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, 'pasteIntoEditor', editor, pasteWidgetVisibleCtx, { id: changePasteTypeCommandId, label: localize(927, "Show paste options...") }, () => CopyPasteController_1._configureDefaultAction ? [CopyPasteController_1._configureDefaultAction] : []));
     }
@@ -99,16 +93,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         await this._currentPasteOperation;
     }
     handleCopy(e) {
-        let id = null;
-        if (e.clipboardData) {
-            const [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            const storedMetadata = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
-            id = storedMetadata?.id || null;
-            this._logService.trace('CopyPasteController#handleCopy for id : ', id, ' with text.length : ', text.length);
-        }
-        else {
-            this._logService.trace('CopyPasteController#handleCopy');
-        }
+        this._logService.trace('CopyPasteController#handleCopy');
         if (!this._editor.hasTextFocus()) {
             return;
         }
@@ -116,28 +101,18 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         // This is needed because on web, the browser clipboard is faked out using an in-memory store.
         // This means the resources clipboard is not properly updated when copying from the editor.
         this._clipboardService.clearInternalState?.();
-        if (!e.clipboardData || !this.isPasteAsEnabled()) {
+        if (!this.isPasteAsEnabled()) {
             return;
         }
         const model = this._editor.getModel();
+        const viewModel = this._editor._getViewModel();
         const selections = this._editor.getSelections();
-        if (!model || !selections?.length) {
+        if (!model || !viewModel || !selections?.length) {
             return;
         }
-        const enableEmptySelectionClipboard = this._editor.getOption(45 /* EditorOption.emptySelectionClipboard */);
-        let ranges = selections;
-        const wasFromEmptySelection = selections.length === 1 && selections[0].isEmpty();
-        if (wasFromEmptySelection) {
-            if (!enableEmptySelectionClipboard) {
-                return;
-            }
-            ranges = [new Range(ranges[0].startLineNumber, 1, ranges[0].startLineNumber, 1 + model.getLineLength(ranges[0].startLineNumber))];
-        }
-        const toCopy = this._editor._getViewModel()?.getPlainTextToCopy(selections, enableEmptySelectionClipboard, isWindows);
-        const multicursorText = Array.isArray(toCopy) ? toCopy : null;
         const defaultPastePayload = {
-            multicursorText,
-            pasteOnNewLine: wasFromEmptySelection,
+            multicursorText: e.dataToCopy.multicursorText ?? null,
+            pasteOnNewLine: e.dataToCopy.isFromEmptySelection,
             mode: null
         };
         const providers = this._languageFeaturesService.documentPasteEditProvider
@@ -147,10 +122,10 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             this.setCopyMetadata(e.clipboardData, { defaultPastePayload });
             return;
         }
-        const dataTransfer = toVSDataTransfer(e.clipboardData);
+        const dataTransfer = new VSDataTransfer();
         const providerCopyMimeTypes = providers.flatMap(x => x.copyMimeTypes ?? []);
         // Save off a handle pointing to data that VS Code maintains.
-        const handle = id ?? generateUuid();
+        const handle = generateUuid();
         this.setCopyMetadata(e.clipboardData, {
             id: handle,
             providerCopyMimeTypes,
@@ -159,7 +134,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         const operations = providers.map((provider) => {
             return {
                 providerMimeTypes: provider.copyMimeTypes,
-                operation: createCancelablePromise(token => provider.prepareDocumentPaste(model, ranges, dataTransfer, token)
+                operation: createCancelablePromise(token => provider.prepareDocumentPaste(model, e.dataToCopy.sourceRanges, dataTransfer, token)
                     .catch(err => {
                     console.error(err);
                     return undefined;
@@ -170,17 +145,15 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         CopyPasteController_1._currentCopyOperation = { handle, operations };
     }
     async handlePaste(e) {
-        if (e.clipboardData) {
-            const [text, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-            const metadataComputed = metadata || InMemoryClipboardMetadataManager.INSTANCE.get(text);
-            this._logService.trace('CopyPasteController#handlePaste for id : ', metadataComputed?.id);
-        }
-        else {
-            this._logService.trace('CopyPasteController#handlePaste');
+        this._logService.trace('CopyPasteController#handlePaste for id : ', e.metadata?.id);
+        if (!this._editor.hasTextFocus()) {
+            return;
         }
-        if (!e.clipboardData || !this._editor.hasTextFocus()) {
+        const dataTransfer = e.toExternalVSDataTransfer();
+        if (!dataTransfer) {
             return;
         }
+        dataTransfer.delete(vscodeClipboardMime);
         MessageController.get(this._editor)?.closeMessage();
         this._currentPasteOperation?.cancel();
         this._currentPasteOperation = undefined;
@@ -196,8 +169,6 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         }
         const metadata = this.fetchCopyMetadata(e);
         this._logService.trace('CopyPasteController#handlePaste with metadata : ', metadata?.id, ' and text.length : ', e.clipboardData.getData('text/plain').length);
-        const dataTransfer = toExternalVSDataTransfer(e.clipboardData);
-        dataTransfer.delete(vscodeClipboardMime);
         const fileTypes = Array.from(e.clipboardData.files).map(file => file.type);
         const allPotentialMimeTypes = [
             ...e.clipboardData.types,
@@ -225,21 +196,19 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             if (this._pasteAsActionContext?.preferred) {
                 this.showPasteAsNoEditMessage(selections, this._pasteAsActionContext.preferred);
                 // Also prevent default paste from applying
-                e.preventDefault();
-                e.stopImmediatePropagation();
+                e.setHandled();
             }
             return;
         }
         // Prevent the editor's default paste handler from running.
         // Note that after this point, we are fully responsible for handling paste.
         // If we can't provider a paste for any reason, we need to explicitly delegate pasting back to the editor.
-        e.preventDefault();
-        e.stopImmediatePropagation();
+        e.setHandled();
         if (this._pasteAsActionContext) {
             this.showPasteAsPick(this._pasteAsActionContext.preferred, allProviders, selections, dataTransfer, metadata);
         }
         else {
-            this.doPasteInline(allProviders, selections, dataTransfer, metadata, e);
+            this.doPasteInline(allProviders, selections, dataTransfer, metadata, e.browserEvent);
         }
     }
     showPasteAsNoEditMessage(selections, preference) {
@@ -432,15 +401,12 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             title: localize(934, "Running paste handlers"),
         }, () => p);
     }
-    setCopyMetadata(dataTransfer, metadata) {
+    setCopyMetadata(clipboardData, metadata) {
         this._logService.trace('CopyPasteController#setCopyMetadata new id : ', metadata.id);
-        dataTransfer.setData(vscodeClipboardMime, JSON.stringify(metadata));
+        clipboardData.setData(vscodeClipboardMime, JSON.stringify(metadata));
     }
     fetchCopyMetadata(e) {
         this._logService.trace('CopyPasteController#fetchCopyMetadata');
-        if (!e.clipboardData) {
-            return;
-        }
         // Prefer using the clipboard data we saved off
         const rawMetadata = e.clipboardData.getData(vscodeClipboardMime);
         if (rawMetadata) {
@@ -451,14 +417,12 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 return undefined;
             }
         }
-        // Otherwise try to extract the generic text editor metadata
-        const [_, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
-        if (metadata) {
+        if (e.metadata) {
             return {
                 defaultPastePayload: {
-                    mode: metadata.mode,
-                    multicursorText: metadata.multicursorText ?? null,
-                    pasteOnNewLine: !!metadata.isFromEmptySelection,
+                    mode: e.metadata.mode,
+                    multicursorText: e.metadata.multicursorText ?? null,
+                    pasteOnNewLine: !!e.metadata.isFromEmptySelection,
                 },
             };
         }