@codingame/monaco-vscode-api 25.1.2 → 26.0.0

package/vscode/src/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController.js

@@ -1,15 +1,13 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-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';
@@ -22,11 +20,8 @@ import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { ProgressLocation } from '../../../../platform/progress/common/progress.js';
 import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
-import { ClipboardEventUtils, InMemoryClipboardMetadataManager } from '../../../browser/controller/editContext/clipboardUtils.js';
-import { toVSDataTransfer, toExternalVSDataTransfer } from '../../../browser/dataTransfer.js';
 import { IBulkEditService } from '../../../browser/services/bulkEditService.service.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
-import { Range } from '../../../common/core/range.js';
 import { Handler } from '../../../common/editorCommon.js';
 import { DocumentPasteTriggerKind } from '../../../common/languages.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
@@ -38,20 +33,35 @@ import { createCombinedWorkspaceEdit, sortEditsByYieldTo } from './edit.js';
 import { PostEditWidgetManager } from './postEditWidget.js';
 
 var CopyPasteController_1;
-const changePasteTypeCommandId = 'editor.changePasteType';
-const pasteAsPreferenceConfig = 'editor.pasteAs.preferences';
-const pasteWidgetVisibleCtx = ( new RawContextKey('pasteWidgetVisible', false, ( localize(1018, "Whether the paste widget is showing"))));
-const vscodeClipboardMime = 'application/vnd.code.copymetadata';
+const changePasteTypeCommandId = "editor.changePasteType";
+const pasteAsPreferenceConfig = "editor.pasteAs.preferences";
+const pasteWidgetVisibleCtx = ( new RawContextKey("pasteWidgetVisible", false, ( localize(1023, "Whether the paste widget is showing"))));
+const vscodeClipboardMime = "application/vnd.code.copymetadata";
 let CopyPasteController = class CopyPasteController extends Disposable {
-    static { CopyPasteController_1 = this; }
-    static { this.ID = 'editor.contrib.copyPasteActionController'; }
+    static {
+        CopyPasteController_1 = this;
+    }
+    static {
+        this.ID = "editor.contrib.copyPasteActionController";
+    }
     static get(editor) {
         return editor.getContribution(CopyPasteController_1.ID);
     }
     static setConfigureDefaultAction(action) {
         CopyPasteController_1._configureDefaultAction = action;
     }
-    constructor(editor, instantiationService, _logService, _bulkEditService, _clipboardService, _commandService, _configService, _languageFeaturesService, _quickInputService, _progressService) {
+    constructor(
+        editor,
+        instantiationService,
+        _logService,
+        _bulkEditService,
+        _clipboardService,
+        _commandService,
+        _configService,
+        _languageFeaturesService,
+        _quickInputService,
+        _progressService
+    ) {
         super();
         this._logService = _logService;
         this._bulkEditService = _bulkEditService;
@@ -62,25 +72,30 @@ 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._pasteProgressManager = this._register(( new InlineProgressManager('pasteIntoEditor', editor, instantiationService)));
-        this._postPasteWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, 'pasteIntoEditor', editor, pasteWidgetVisibleCtx, { id: changePasteTypeCommandId, label: ( localize(1019, "Show paste options...")) }, () => CopyPasteController_1._configureDefaultAction ? [CopyPasteController_1._configureDefaultAction] : []));
+        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(1024, "Show paste options..."))
+            }, () => CopyPasteController_1._configureDefaultAction ? [CopyPasteController_1._configureDefaultAction] : [])
+        );
     }
     changePasteType() {
         this._postPasteWidgetManager.tryShowSelector();
     }
     async pasteAs(preferred) {
-        this._logService.trace('CopyPasteController.pasteAs');
+        this._logService.trace("CopyPasteController.pasteAs");
         this._editor.focus();
         try {
-            this._logService.trace('Before calling editor.action.clipboardPasteAction');
-            this._pasteAsActionContext = { preferred };
-            await this._commandService.executeCommand('editor.action.clipboardPasteAction');
-        }
-        finally {
+            this._logService.trace("Before calling editor.action.clipboardPasteAction");
+            this._pasteAsActionContext = {
+                preferred
+            };
+            await this._commandService.executeCommand("editor.action.clipboardPasteAction");
+        } finally {
             this._pasteAsActionContext = undefined;
         }
     }
@@ -94,89 +109,67 @@ 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;
         }
         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(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
-            .ordered(model)
-            .filter(x => !!x.prepareDocumentPaste);
+        const providers = this._languageFeaturesService.documentPasteEditProvider.ordered(model).filter(x => !!x.prepareDocumentPaste);
         if (!providers.length) {
-            this.setCopyMetadata(e.clipboardData, { defaultPastePayload });
+            this.setCopyMetadata(e.clipboardData, {
+                defaultPastePayload
+            });
             return;
         }
-        const dataTransfer = toVSDataTransfer(e.clipboardData);
+        const dataTransfer = ( new VSDataTransfer());
         const providerCopyMimeTypes = providers.flatMap(x => x.copyMimeTypes ?? []);
-        const handle = id ?? generateUuid();
+        const handle = generateUuid();
         this.setCopyMetadata(e.clipboardData, {
             id: handle,
             providerCopyMimeTypes,
             defaultPastePayload
         });
-        const operations = ( providers.map((provider) => {
+        const operations = ( providers.map(provider => {
             return {
                 providerMimeTypes: provider.copyMimeTypes,
-                operation: createCancelablePromise(token => provider.prepareDocumentPaste(model, ranges, dataTransfer, token)
-                    .catch(err => {
-                    console.error(err);
-                    return undefined;
-                }))
+                operation: createCancelablePromise(
+                    token => provider.prepareDocumentPaste(model, e.dataToCopy.sourceRanges, dataTransfer, token).catch(err => {
+                        console.error(err);
+                        return undefined;
+                    })
+                )
             };
         }));
         CopyPasteController_1._currentCopyOperation?.operations.forEach(entry => entry.operation.cancel());
-        CopyPasteController_1._currentCopyOperation = { handle, operations };
+        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;
@@ -185,25 +178,25 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         if (!selections?.length || !model) {
             return;
         }
-        if (this._editor.getOption(EditorOption.readOnly)
-            || (!this.isPasteAsEnabled() && !this._pasteAsActionContext)
-        ) {
+        if (
+        this._editor.getOption(EditorOption.readOnly) || (!this.isPasteAsEnabled() && !this._pasteAsActionContext)) {
             return;
         }
         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);
+        this._logService.trace(
+            "CopyPasteController#handlePaste with metadata : ",
+            metadata?.id,
+            " and text.length : ",
+            e.clipboardData.getData("text/plain").length
+        );
         const fileTypes = ( Array.from(e.clipboardData.files).map(file => file.type));
         const allPotentialMimeTypes = [
             ...e.clipboardData.types,
             ...fileTypes,
             ...(metadata?.providerCopyMimeTypes ?? []),
-            Mimes.uriList,
+            Mimes.uriList
         ];
-        const allProviders = this._languageFeaturesService.documentPasteEditProvider
-            .ordered(model)
-            .filter(provider => {
+        const allProviders = this._languageFeaturesService.documentPasteEditProvider.ordered(model).filter(provider => {
             const preference = this._pasteAsActionContext?.preferred;
             if (preference) {
                 if (!this.providerMatchesPreference(provider, preference)) {
@@ -215,30 +208,29 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         if (!allProviders.length) {
             if (this._pasteAsActionContext?.preferred) {
                 this.showPasteAsNoEditMessage(selections, this._pasteAsActionContext.preferred);
-                e.preventDefault();
-                e.stopImmediatePropagation();
+                e.setHandled();
             }
             return;
         }
-        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.showPasteAsPick(
+                this._pasteAsActionContext.preferred,
+                allProviders,
+                selections,
+                dataTransfer,
+                metadata
+            );
+        } else {
+            this.doPasteInline(allProviders, selections, dataTransfer, metadata, e.browserEvent);
         }
     }
     showPasteAsNoEditMessage(selections, preference) {
-        const kindLabel = 'only' in preference
-            ? preference.only.value
-            : 'preferences' in preference
-                ? (preference.preferences.length ? ( preference.preferences.map(preference => preference.value)).join(', ') : ( localize(1020, "empty")))
-                : preference.providerId;
-        MessageController.get(this._editor)?.showMessage(( localize(1021, "No paste edits for '{0}' found", kindLabel)), selections[0].getStartPosition());
+        const kindLabel = "only" in preference ? preference.only.value : "preferences" in preference ? (preference.preferences.length ? ( preference.preferences.map(preference => preference.value)).join(", ") : ( localize(1025, "empty"))) : preference.providerId;
+        MessageController.get(this._editor)?.showMessage(( localize(1026, "No paste edits for '{0}' found", kindLabel)), selections[0].getStartPosition());
     }
     doPasteInline(allProviders, selections, dataTransfer, metadata, clipboardEvent) {
-        this._logService.trace('CopyPasteController#doPasteInline');
+        this._logService.trace("CopyPasteController#doPasteInline");
         const editor = this._editor;
         if (!editor.hasModel()) {
             return;
@@ -248,7 +240,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             CodeEditorStateFlag.Value | CodeEditorStateFlag.Selection,
             undefined
         ));
-        const p = createCancelablePromise(async (pToken) => {
+        const p = createCancelablePromise(async pToken => {
             const editor = this._editor;
             if (!editor.hasModel()) {
                 return;
@@ -264,13 +256,12 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                     return;
                 }
                 const supportedProviders = allProviders.filter(provider => this.isSupportedPasteProvider(provider, dataTransfer));
-                if (!supportedProviders.length
-                    || (supportedProviders.length === 1 && supportedProviders[0] instanceof DefaultTextPasteOrDropEditProvider)
-                ) {
+                if (
+                !supportedProviders.length || (supportedProviders.length === 1 && supportedProviders[0] instanceof DefaultTextPasteOrDropEditProvider)) {
                     return this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
                 }
                 const context = {
-                    triggerKind: DocumentPasteTriggerKind.Automatic,
+                    triggerKind: DocumentPasteTriggerKind.Automatic
                 };
                 const editSession = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, context, token);
                 disposables.add(editSession);
@@ -281,14 +272,17 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                     return this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
                 }
                 if (editSession.edits.length) {
-                    const canShowWidget = editor.getOption(EditorOption.pasteAs).showPasteSelector === 'afterPaste';
-                    return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, { activeEditIndex: this.getInitialActiveEditIndex(model, editSession.edits), allEdits: editSession.edits }, canShowWidget, async (edit, resolveToken) => {
+                    const canShowWidget = editor.getOption(EditorOption.pasteAs).showPasteSelector === "afterPaste";
+                    return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, {
+                        activeEditIndex: this.getInitialActiveEditIndex(model, editSession.edits),
+                        allEdits: editSession.edits
+                    }, canShowWidget, async (edit, resolveToken) => {
                         if (!edit.provider.resolveDocumentPasteEdit) {
                             return edit;
                         }
                         const resolveP = edit.provider.resolveDocumentPasteEdit(edit, resolveToken);
                         const showP = ( new DeferredPromise());
-                        const resolved = await this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localize(1022, "Resolving paste edit for '{0}'. Click to cancel", edit.title)), raceCancellation(Promise.race([showP.p, resolveP]), resolveToken), {
+                        const resolved = await this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localize(1027, "Resolving paste edit for '{0}'. Click to cancel", edit.title)), raceCancellation(Promise.race([showP.p, resolveP]), resolveToken), {
                             cancel: () => showP.cancel()
                         }, 0);
                         if (resolved) {
@@ -299,15 +293,14 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                     }, token);
                 }
                 await this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
-            }
-            finally {
+            } finally {
                 disposables.dispose();
                 if (this._currentPasteOperation === p) {
                     this._currentPasteOperation = undefined;
                 }
             }
         });
-        this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localize(1023, "Running paste handlers. Click to cancel and do basic paste")), p, {
+        this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localize(1028, "Running paste handlers. Click to cancel and do basic paste")), p, {
             cancel: async () => {
                 p.cancel();
                 if (editorStateCts.token.isCancellationRequested) {
@@ -321,8 +314,8 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         this._currentPasteOperation = p;
     }
     showPasteAsPick(preference, allProviders, selections, dataTransfer, metadata) {
-        this._logService.trace('CopyPasteController#showPasteAsPick');
-        const p = createCancelablePromise(async (token) => {
+        this._logService.trace("CopyPasteController#showPasteAsPick");
+        const p = createCancelablePromise(async token => {
             const editor = this._editor;
             if (!editor.hasModel()) {
                 return;
@@ -340,28 +333,35 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 if (tokenSource.token.isCancellationRequested) {
                     return;
                 }
-                let supportedProviders = allProviders.filter(provider => this.isSupportedPasteProvider(provider, dataTransfer, preference));
+                let supportedProviders = allProviders.filter(
+                    provider => this.isSupportedPasteProvider(provider, dataTransfer, preference)
+                );
                 if (preference) {
                     supportedProviders = supportedProviders.filter(provider => this.providerMatchesPreference(provider, preference));
                 }
                 const context = {
                     triggerKind: DocumentPasteTriggerKind.PasteAs,
-                    only: preference && 'only' in preference ? preference.only : undefined,
+                    only: preference && "only" in preference ? preference.only : undefined
                 };
-                let editSession = disposables.add(await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, context, tokenSource.token));
+                let editSession = disposables.add(await this.getPasteEdits(
+                    supportedProviders,
+                    dataTransfer,
+                    model,
+                    selections,
+                    context,
+                    tokenSource.token
+                ));
                 if (tokenSource.token.isCancellationRequested) {
                     return;
                 }
                 if (preference) {
                     editSession = {
                         edits: editSession.edits.filter(edit => {
-                            if ('only' in preference) {
+                            if ("only" in preference) {
                                 return preference.only.contains(edit.kind);
-                            }
-                            else if ('preferences' in preference) {
+                            } else if ("preferences" in preference) {
                                 return ( preference.preferences.some(preference => preference.contains(edit.kind)));
-                            }
-                            else {
+                            } else {
                                 return preference.providerId === edit.provider.id;
                             }
                         }),
@@ -377,28 +377,23 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 let pickedEdit;
                 if (preference) {
                     pickedEdit = editSession.edits.at(0);
-                }
-                else {
+                } else {
                     const configureDefaultItem = {
-                        id: 'editor.pasteAs.default',
-                        label: ( localize(1024, "Configure default paste action")),
-                        edit: undefined,
+                        id: "editor.pasteAs.default",
+                        label: ( localize(1029, "Configure default paste action")),
+                        edit: undefined
                     };
-                    const selected = await this._quickInputService.pick([
-                        ...( editSession.edits.map((edit) => ({
-                            label: edit.title,
-                            description: edit.kind?.value,
-                            edit,
-                        }))),
-                        ...(CopyPasteController_1._configureDefaultAction ? [
-                            upcast({ type: 'separator' }),
-                            {
-                                label: CopyPasteController_1._configureDefaultAction.label,
-                                edit: undefined,
-                            }
-                        ] : [])
-                    ], {
-                        placeHolder: ( localize(1025, "Select Paste Action")),
+                    const selected = await this._quickInputService.pick([...( editSession.edits.map(edit => ({
+                        label: edit.title,
+                        description: edit.kind?.value,
+                        edit
+                    }))), ...(CopyPasteController_1._configureDefaultAction ? [upcast({
+                        type: "separator"
+                    }), {
+                        label: CopyPasteController_1._configureDefaultAction.label,
+                        edit: undefined
+                    }] : [])], {
+                        placeHolder: ( localize(1030, "Select Paste Action"))
                     });
                     if (selected === configureDefaultItem) {
                         CopyPasteController_1._configureDefaultAction?.run();
@@ -410,9 +405,10 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                     return;
                 }
                 const combinedWorkspaceEdit = createCombinedWorkspaceEdit(model.uri, selections, pickedEdit);
-                await this._bulkEditService.apply(combinedWorkspaceEdit, { editor: this._editor });
-            }
-            finally {
+                await this._bulkEditService.apply(combinedWorkspaceEdit, {
+                    editor: this._editor
+                });
+            } finally {
                 disposables.dispose();
                 if (this._currentPasteOperation === p) {
                     this._currentPasteOperation = undefined;
@@ -421,45 +417,38 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         });
         this._progressService.withProgress({
             location: ProgressLocation.Window,
-            title: ( localize(1026, "Running paste handlers")),
+            title: ( localize(1031, "Running paste handlers"))
         }, () => p);
     }
-    setCopyMetadata(dataTransfer, metadata) {
-        this._logService.trace('CopyPasteController#setCopyMetadata new id : ', metadata.id);
-        dataTransfer.setData(vscodeClipboardMime, JSON.stringify(metadata));
+    setCopyMetadata(clipboardData, metadata) {
+        this._logService.trace("CopyPasteController#setCopyMetadata new id : ", metadata.id);
+        clipboardData.setData(vscodeClipboardMime, JSON.stringify(metadata));
     }
     fetchCopyMetadata(e) {
-        this._logService.trace('CopyPasteController#fetchCopyMetadata');
-        if (!e.clipboardData) {
-            return;
-        }
+        this._logService.trace("CopyPasteController#fetchCopyMetadata");
         const rawMetadata = e.clipboardData.getData(vscodeClipboardMime);
         if (rawMetadata) {
             try {
                 return JSON.parse(rawMetadata);
-            }
-            catch {
+            } catch {
                 return undefined;
             }
         }
-        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
+                }
             };
         }
         return undefined;
     }
     async mergeInDataFromCopy(allProviders, dataTransfer, metadata, token) {
-        this._logService.trace('CopyPasteController#mergeInDataFromCopy with metadata : ', metadata?.id);
+        this._logService.trace("CopyPasteController#mergeInDataFromCopy with metadata : ", metadata?.id);
         if (metadata?.id && CopyPasteController_1._currentCopyOperation?.handle === metadata.id) {
-            const toResolve = ( CopyPasteController_1._currentCopyOperation.operations
-                .filter(op => ( allProviders.some(provider => ( provider.pasteMimeTypes.some(type => matchesMimeType(type, op.providerMimeTypes))))))
-                .map(op => op.operation));
+            const toResolve = ( CopyPasteController_1._currentCopyOperation.operations.filter(op => ( allProviders.some(provider => ( provider.pasteMimeTypes.some(type => matchesMimeType(type, op.providerMimeTypes)))))).map(op => op.operation));
             const toMergeResults = await Promise.all(toResolve);
             if (token.isCancellationRequested) {
                 return;
@@ -484,15 +473,17 @@ let CopyPasteController = class CopyPasteController extends Disposable {
     }
     async getPasteEdits(providers, dataTransfer, model, selections, context, token) {
         const disposables = ( new DisposableStore());
-        const results = await raceCancellation(Promise.all(( providers.map(async (provider) => {
+        const results = await raceCancellation(Promise.all(( providers.map(async provider => {
             try {
                 const edits = await provider.provideDocumentPasteEdits?.(model, selections, dataTransfer, context, token);
                 if (edits) {
                     disposables.add(edits);
                 }
-                return edits?.edits?.map(edit => ({ ...edit, provider }));
-            }
-            catch (err) {
+                return edits?.edits?.map(edit => ({
+                    ...edit,
+                    provider
+                }));
+            } catch (err) {
                 if (!isCancellationError(err)) {
                     console.error(err);
                 }
@@ -508,8 +499,8 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         };
     }
     async applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent) {
-        const textDataTransfer = dataTransfer.get(Mimes.text) ?? dataTransfer.get('text');
-        const text = (await textDataTransfer?.asString()) ?? '';
+        const textDataTransfer = dataTransfer.get(Mimes.text) ?? dataTransfer.get("text");
+        const text = (await textDataTransfer?.asString()) ?? "";
         if (token.isCancellationRequested) {
             return;
         }
@@ -518,10 +509,10 @@ let CopyPasteController = class CopyPasteController extends Disposable {
             text,
             pasteOnNewLine: metadata?.defaultPastePayload.pasteOnNewLine ?? false,
             multicursorText: metadata?.defaultPastePayload.multicursorText ?? null,
-            mode: null,
+            mode: null
         };
-        this._logService.trace('CopyPasteController#applyDefaultPasteHandler for id : ', metadata?.id);
-        this._editor.trigger('keyboard', Handler.Paste, payload);
+        this._logService.trace("CopyPasteController#applyDefaultPasteHandler for id : ", metadata?.id);
+        this._editor.trigger("keyboard", Handler.Paste, payload);
     }
     isSupportedPasteProvider(provider, dataTransfer, preference) {
         if (!provider.pasteMimeTypes?.some(type => dataTransfer.matches(type))) {
@@ -530,18 +521,18 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         return !preference || this.providerMatchesPreference(provider, preference);
     }
     providerMatchesPreference(provider, preference) {
-        if ('only' in preference) {
+        if ("only" in preference) {
             return ( provider.providedPasteEditKinds.some(providedKind => preference.only.contains(providedKind)));
-        }
-        else if ('preferences' in preference) {
+        } else if ("preferences" in preference) {
             return ( preference.preferences.some(providedKind => ( preference.preferences.some(preferredKind => preferredKind.contains(providedKind)))));
-        }
-        else {
+        } else {
             return provider.id === preference.providerId;
         }
     }
     getInitialActiveEditIndex(model, edits) {
-        const preferredProviders = this._configService.getValue(pasteAsPreferenceConfig, { resource: model.uri });
+        const preferredProviders = this._configService.getValue(pasteAsPreferenceConfig, {
+            resource: model.uri
+        });
         for (const config of Array.isArray(preferredProviders) ? preferredProviders : []) {
             const desiredKind = ( new HierarchicalKind(config));
             const editIndex = edits.findIndex(edit => desiredKind.contains(edit.kind));
@@ -552,16 +543,6 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         return 0;
     }
 };
-CopyPasteController = CopyPasteController_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IBulkEditService)),
-    ( __param(4, IClipboardService)),
-    ( __param(5, ICommandService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, ILanguageFeaturesService)),
-    ( __param(8, IQuickInputService)),
-    ( __param(9, IProgressService))
-], CopyPasteController));
+CopyPasteController = CopyPasteController_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, IBulkEditService)), ( __param(4, IClipboardService)), ( __param(5, ICommandService)), ( __param(6, IConfigurationService)), ( __param(7, ILanguageFeaturesService)), ( __param(8, IQuickInputService)), ( __param(9, IProgressService))], CopyPasteController));
 
 export { CopyPasteController, changePasteTypeCommandId, pasteAsPreferenceConfig, pasteWidgetVisibleCtx };