@codingame/monaco-vscode-api 6.0.3 → 7.0.1

package/vscode/src/vs/editor/contrib/codeAction/browser/lightBulbWidget.js

@@ -11,7 +11,6 @@ import { EditorOption } from '../../../common/config/editorOptions.js';
 import { computeIndentLevel } from '../../../common/model/utils.js';
 import { autoFixCommandId, quickFixCommandId } from './codeAction.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 var LightBulbWidget_1;
 const _moduleId = "vs/editor/contrib/codeAction/browser/lightBulbWidget";
@@ -38,7 +37,7 @@ let LightBulbWidget = class LightBulbWidget extends Disposable {
     static { LightBulbWidget_1 = this; }
     static { this.ID = 'editor.contrib.lightbulbWidget'; }
     static { this._posPref = [ContentWidgetPositionPreference.EXACT]; }
-    constructor(_editor, _keybindingService, commandService) {
+    constructor(_editor, _keybindingService) {
         super();
         this._editor = _editor;
         this._keybindingService = _keybindingService;
@@ -124,8 +123,23 @@ let LightBulbWidget = class LightBulbWidget extends Disposable {
         let effectiveLineNumber = lineNumber;
         let effectiveColumnNumber = 1;
         if (!lineHasSpace) {
+            const isLineEmptyOrIndented = (lineNumber) => {
+                const lineContent = model.getLineContent(lineNumber);
+                return /^\s*$|^\s+/.test(lineContent) || lineContent.length <= effectiveColumnNumber;
+            };
             if (lineNumber > 1 && !isFolded(lineNumber - 1)) {
-                effectiveLineNumber -= 1;
+                const lineCount = model.getLineCount();
+                const endLine = lineNumber === lineCount;
+                const prevLineEmptyOrIndented = lineNumber > 1 && isLineEmptyOrIndented(lineNumber - 1);
+                const nextLineEmptyOrIndented = !endLine && isLineEmptyOrIndented(lineNumber + 1);
+                const currLineEmptyOrIndented = isLineEmptyOrIndented(lineNumber);
+                const notEmpty = !nextLineEmptyOrIndented && !prevLineEmptyOrIndented;
+                if (prevLineEmptyOrIndented || endLine || (notEmpty && !currLineEmptyOrIndented)) {
+                    effectiveLineNumber -= 1;
+                }
+                else if (nextLineEmptyOrIndented || (notEmpty && currLineEmptyOrIndented)) {
+                    effectiveLineNumber += 1;
+                }
             }
             else if ((lineNumber < model.getLineCount()) && !isFolded(lineNumber + 1)) {
                 effectiveLineNumber += 1;
@@ -218,7 +232,6 @@ let LightBulbWidget = class LightBulbWidget extends Disposable {
     }
 };
 LightBulbWidget = LightBulbWidget_1 = ( (__decorate([
-    ( (__param(1, IKeybindingService))),
-    ( (__param(2, ICommandService)))
+    ( (__param(1, IKeybindingService)))
 ], LightBulbWidget)));
 export { LightBulbWidget };

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorHoverParticipant.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { AsyncIterableObject } from '../../../../base/common/async.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { Color, RGBA } from '../../../../base/common/color.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
 import { EditorOption } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
 import { TrackedRangeStickiness } from '../../../common/model.js';
@@ -10,9 +10,11 @@ import { getColors, getColorPresentations } from './color.js';
 import { ColorDetector } from './colorDetector.js';
 import { ColorPickerModel } from './colorPickerModel.js';
 import { ColorPickerWidget } from './colorPickerWidget.js';
-import { HoverAnchorType } from '../../hover/browser/hoverTypes.js';
+import { RenderedHoverParts, HoverAnchorType } from '../../hover/browser/hoverTypes.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { Dimension } from '../../../../base/browser/dom.js';
+import { localizeWithPath } from '../../../../nls.js';
+const _moduleId = "vs/editor/contrib/colorPicker/browser/colorHoverParticipant";
 class ColorHover {
     constructor(owner, range, model, provider) {
         this.owner = owner;
@@ -60,12 +62,35 @@ let ColorHoverParticipant = class ColorHoverParticipant {
         return [];
     }
     renderHoverParts(context, hoverParts) {
-        return renderHoverParts(this, this._editor, this._themeService, hoverParts, context);
+        const renderedPart = renderHoverParts(this, this._editor, this._themeService, hoverParts, context);
+        if (!renderedPart) {
+            return (
+                 (new RenderedHoverParts([]))
+            );
+        }
+        this._colorPicker = renderedPart.colorPicker;
+        const renderedHoverPart = {
+            hoverPart: renderedPart.hoverPart,
+            hoverElement: this._colorPicker.domNode,
+            dispose() { renderedPart.disposables.dispose(); }
+        };
+        return (
+             (new RenderedHoverParts([renderedHoverPart]))
+        );
+    }
+    getAccessibleContent(hoverPart) {
+        return ( localizeWithPath(_moduleId, 0, 'There is a color picker here.'));
+    }
+    handleResize() {
+        this._colorPicker?.layout();
+    }
+    isColorPickerVisible() {
+        return !!this._colorPicker;
     }
 };
-ColorHoverParticipant = ( __decorate([
-    ( __param(1, IThemeService))
-], ColorHoverParticipant));
+ColorHoverParticipant = ( (__decorate([
+    ( (__param(1, IThemeService)))
+], ColorHoverParticipant)));
 class StandaloneColorPickerHover {
     constructor(owner, range, model, provider) {
         this.owner = owner;
@@ -109,12 +134,12 @@ let StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant {
             return;
         }
         const colorPickerModel = colorHoverData.model;
-        let range = ( new Range(
+        let range = ( (new Range(
             colorHoverData.range.startLineNumber,
             colorHoverData.range.startColumn,
             colorHoverData.range.endLineNumber,
             colorHoverData.range.endColumn
-        ));
+        )));
         if (this._color) {
             await _updateColorPresentations(this._editor.getModel(), colorPickerModel, this._color, range, colorHoverData);
             range = _updateEditorModel(this._editor, range, colorPickerModel);
@@ -130,59 +155,62 @@ let StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant {
         return this._color;
     }
 };
-StandaloneColorPickerParticipant = ( __decorate([
-    ( __param(1, IThemeService))
-], StandaloneColorPickerParticipant));
+StandaloneColorPickerParticipant = ( (__decorate([
+    ( (__param(1, IThemeService)))
+], StandaloneColorPickerParticipant)));
 async function _createColorHover(participant, editorModel, colorInfo, provider) {
     const originalText = editorModel.getValueInRange(colorInfo.range);
     const { red, green, blue, alpha } = colorInfo.color;
-    const rgba = ( new RGBA(
+    const rgba = ( (new RGBA(
         Math.round(red * 255),
         Math.round(green * 255),
         Math.round(blue * 255),
         alpha
-    ));
-    const color = ( new Color(rgba));
+    )));
+    const color = ( (new Color(rgba)));
     const colorPresentations = await getColorPresentations(editorModel, colorInfo, provider, CancellationToken.None);
-    const model = ( new ColorPickerModel(color, [], 0));
+    const model = ( (new ColorPickerModel(color, [], 0)));
     model.colorPresentations = colorPresentations || [];
     model.guessColorPresentation(color, originalText);
     if (participant instanceof ColorHoverParticipant) {
-        return ( new ColorHover(participant, Range.lift(colorInfo.range), model, provider));
+        return (
+             (new ColorHover(participant, Range.lift(colorInfo.range), model, provider))
+        );
     }
     else {
-        return ( new StandaloneColorPickerHover(participant, Range.lift(colorInfo.range), model, provider));
+        return (
+             (new StandaloneColorPickerHover(participant, Range.lift(colorInfo.range), model, provider))
+        );
     }
 }
 function renderHoverParts(participant, editor, themeService, hoverParts, context) {
     if (hoverParts.length === 0 || !editor.hasModel()) {
-        return Disposable.None;
+        return undefined;
     }
     if (context.setMinimumDimensions) {
         const minimumHeight = editor.getOption(EditorOption.lineHeight) + 8;
-        context.setMinimumDimensions(( new Dimension(302, minimumHeight)));
+        context.setMinimumDimensions(( (new Dimension(302, minimumHeight))));
     }
-    const disposables = ( new DisposableStore());
+    const disposables = ( (new DisposableStore()));
     const colorHover = hoverParts[0];
     const editorModel = editor.getModel();
     const model = colorHover.model;
-    const widget = disposables.add(( new ColorPickerWidget(
+    const colorPicker = disposables.add(( (new ColorPickerWidget(
         context.fragment,
         model,
         editor.getOption(EditorOption.pixelRatio),
         themeService,
         participant instanceof StandaloneColorPickerParticipant
-    )));
-    context.setColorPicker(widget);
+    ))));
     let editorUpdatedByColorPicker = false;
-    let range = ( new Range(
+    let range = ( (new Range(
         colorHover.range.startLineNumber,
         colorHover.range.startColumn,
         colorHover.range.endLineNumber,
         colorHover.range.endColumn
-    ));
+    )));
     if (participant instanceof StandaloneColorPickerParticipant) {
-        const color = hoverParts[0].model.color;
+        const color = colorHover.model.color;
         participant.color = color;
         _updateColorPresentations(editorModel, model, color, range, colorHover);
         disposables.add(model.onColorFlushed((color) => {
@@ -208,7 +236,7 @@ function renderHoverParts(participant, editor, themeService, hoverParts, context
             editor.focus();
         }
     }));
-    return disposables;
+    return { hoverPart: colorHover, colorPicker, disposables };
 }
 function _updateEditorModel(editor, range, model) {
     const textEdits = [];

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorPickerWidget.js

@@ -359,10 +359,10 @@ class ColorPickerWidget extends Widget {
         this.model = model;
         this.pixelRatio = pixelRatio;
         this._register(PixelRatio.getInstance(getWindow(container)).onDidChange(() => this.layout()));
-        const element = $('.colorpicker-widget');
-        container.appendChild(element);
-        this.header = this._register(( (new ColorPickerHeader(element, this.model, themeService, standaloneColorPicker))));
-        this.body = this._register(( (new ColorPickerBody(element, this.model, this.pixelRatio, standaloneColorPicker))));
+        this._domNode = $('.colorpicker-widget');
+        container.appendChild(this._domNode);
+        this.header = this._register(( (new ColorPickerHeader(this._domNode, this.model, themeService, standaloneColorPicker))));
+        this.body = this._register(( (new ColorPickerBody(this._domNode, this.model, this.pixelRatio, standaloneColorPicker))));
     }
     getId() {
         return ColorPickerWidget.ID;
@@ -370,5 +370,8 @@ class ColorPickerWidget extends Widget {
     layout() {
         this.body.layout();
     }
+    get domNode() {
+        return this._domNode;
+    }
 }
 export { ColorPickerBody, ColorPickerHeader, ColorPickerWidget, InsertButton };

package/vscode/src/vs/editor/contrib/colorPicker/browser/standaloneColorPickerWidget.js

@@ -194,39 +194,39 @@ let StandaloneColorPickerWidget = class StandaloneColorPickerWidget extends Disp
     _render(colorHover, foundInEditor) {
         const fragment = document.createDocumentFragment();
         const statusBar = this._register(( new EditorHoverStatusBar(this._keybindingService)));
-        let colorPickerWidget;
         const context = {
             fragment,
             statusBar,
-            setColorPicker: (widget) => colorPickerWidget = widget,
             onContentsChanged: () => { },
             hide: () => this.hide()
         };
         this._colorHover = colorHover;
-        this._register(this._standaloneColorPickerParticipant.renderHoverParts(context, [colorHover]));
-        if (colorPickerWidget === undefined) {
+        const renderedHoverPart = this._standaloneColorPickerParticipant.renderHoverParts(context, [colorHover]);
+        if (!renderedHoverPart) {
             return;
         }
+        this._register(renderedHoverPart.disposables);
+        const colorPicker = renderedHoverPart.colorPicker;
         this._body.classList.add('standalone-colorpicker-body');
         this._body.style.maxHeight = Math.max(this._editor.getLayoutInfo().height / 4, 250) + 'px';
         this._body.style.maxWidth = Math.max(this._editor.getLayoutInfo().width * 0.66, 500) + 'px';
         this._body.tabIndex = 0;
         this._body.appendChild(fragment);
-        colorPickerWidget.layout();
-        const colorPickerBody = colorPickerWidget.body;
+        colorPicker.layout();
+        const colorPickerBody = colorPicker.body;
         const saturationBoxWidth = colorPickerBody.saturationBox.domNode.clientWidth;
         const widthOfOriginalColorBox = colorPickerBody.domNode.clientWidth - saturationBoxWidth - CLOSE_BUTTON_WIDTH - PADDING;
-        const enterButton = colorPickerWidget.body.enterButton;
+        const enterButton = colorPicker.body.enterButton;
         enterButton?.onClicked(() => {
             this.updateEditor();
             this.hide();
         });
-        const colorPickerHeader = colorPickerWidget.header;
+        const colorPickerHeader = colorPicker.header;
         const pickedColorNode = colorPickerHeader.pickedColorNode;
         pickedColorNode.style.width = saturationBoxWidth + PADDING + 'px';
         const originalColorNode = colorPickerHeader.originalColorNode;
         originalColorNode.style.width = widthOfOriginalColorBox + 'px';
-        const closeButton = colorPickerWidget.header.closeButton;
+        const closeButton = colorPicker.header.closeButton;
         closeButton?.onClicked(() => {
             this.hide();
         });

package/vscode/src/vs/editor/contrib/contextmenu/browser/contextmenu.js

@@ -169,7 +169,7 @@ let ContextMenuController = class ContextMenuController {
         const useShadowDOM = this._editor.getOption(EditorOption.useShadowDOM) && !isIOS;
         this._contextMenuIsBeingShownCount++;
         this._contextMenuService.showContextMenu({
-            domForShadowRoot: useShadowDOM ? this._editor.getDomNode() : undefined,
+            domForShadowRoot: useShadowDOM ? this._editor.getOverflowWidgetsDomNode() ?? this._editor.getDomNode() : undefined,
             getAnchor: () => anchor,
             getActions: () => actions,
             getActionViewItem: (action) => {

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

@@ -1,10 +1,11 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { addDisposableListener, getActiveDocument } from '../../../../base/browser/dom.js';
 import { coalesce } from '../../../../base/common/arrays.js';
-import { createCancelablePromise, raceCancellation } from '../../../../base/common/async.js';
+import { createCancelablePromise, raceCancellation, DeferredPromise } from '../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { Mimes } from '../../../../base/common/mime.js';
 import { isWeb, isWindows } from '../../../../base/common/platform.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
@@ -29,6 +30,7 @@ import { ProgressLocation } from '../../../../platform/progress/common/progress.
 import { IProgressService } from '../../../../platform/progress/common/progress.service.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { PostEditWidgetManager } from './postEditWidget.js';
+import { isCancellationError, CancellationError } from '../../../../base/common/errors.js';
 var CopyPasteController_1;
 const _moduleId = "vs/editor/contrib/dropOrPasteInto/browser/copyPasteController";
 const changePasteTypeCommandId = 'editor.changePasteType';
@@ -210,59 +212,100 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         )), selections[0].getStartPosition());
     }
     doPasteInline(allProviders, selections, dataTransfer, metadata, clipboardEvent) {
-        const p = createCancelablePromise(async (token) => {
+        const editor = this._editor;
+        if (!editor.hasModel()) {
+            return;
+        }
+        const editorStateCts = ( (new EditorStateCancellationTokenSource(
+            editor,
+            CodeEditorStateFlag.Value | CodeEditorStateFlag.Selection,
+            undefined
+        )));
+        const p = createCancelablePromise(async (pToken) => {
             const editor = this._editor;
             if (!editor.hasModel()) {
                 return;
             }
             const model = editor.getModel();
-            const tokenSource = ( (new EditorStateCancellationTokenSource(
-                editor,
-                CodeEditorStateFlag.Value | CodeEditorStateFlag.Selection,
-                undefined,
-                token
-            )));
+            const disposables = ( (new DisposableStore()));
+            const cts = disposables.add(( (new CancellationTokenSource(pToken))));
+            disposables.add(editorStateCts.token.onCancellationRequested(() => cts.cancel()));
+            const token = cts.token;
             try {
-                await this.mergeInDataFromCopy(dataTransfer, metadata, tokenSource.token);
-                if (tokenSource.token.isCancellationRequested) {
+                await this.mergeInDataFromCopy(dataTransfer, metadata, token);
+                if (token.isCancellationRequested) {
                     return;
                 }
                 const supportedProviders = allProviders.filter(provider => this.isSupportedPasteProvider(provider, dataTransfer));
                 if (!supportedProviders.length
                     || (supportedProviders.length === 1 && supportedProviders[0] instanceof DefaultTextPasteOrDropEditProvider)
                 ) {
-                    return this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token, clipboardEvent);
+                    return this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
                 }
                 const context = {
                     triggerKind: DocumentPasteTriggerKind.Automatic,
                 };
-                const providerEdits = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, context, tokenSource.token);
-                if (tokenSource.token.isCancellationRequested) {
+                const editSession = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, context, token);
+                disposables.add(editSession);
+                if (token.isCancellationRequested) {
                     return;
                 }
-                if (providerEdits.length === 1 && providerEdits[0].provider instanceof DefaultTextPasteOrDropEditProvider) {
-                    return this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token, clipboardEvent);
+                if (editSession.edits.length === 1 && editSession.edits[0].provider instanceof DefaultTextPasteOrDropEditProvider) {
+                    return this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
                 }
-                if (providerEdits.length) {
+                if (editSession.edits.length) {
                     const canShowWidget = editor.getOption(EditorOption.pasteAs).showPasteSelector === 'afterPaste';
-                    return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, { activeEditIndex: 0, allEdits: providerEdits }, canShowWidget, async (edit, token) => {
-                        const resolved = await edit.provider.resolveDocumentPasteEdit?.(edit, token);
-                        if (resolved) {
-                            edit.additionalEdit = resolved.additionalEdit;
-                        }
-                        return edit;
-                    }, tokenSource.token);
+                    return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, { activeEditIndex: 0, allEdits: editSession.edits }, canShowWidget, (edit, token) => {
+                        return (
+                             (new Promise((resolve, reject) => {
+                                (async () => {
+                                    try {
+                                        const resolveP = edit.provider.resolveDocumentPasteEdit?.(edit, token);
+                                        const showP = ( (new DeferredPromise()));
+                                        const resolved = resolveP && (await this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localizeWithPath(_moduleId, 3, "Resolving paste edit. Click to cancel")), Promise.race([showP.p, resolveP]), {
+                                            cancel: () => {
+                                                showP.cancel();
+                                                return reject(( (new CancellationError())));
+                                            }
+                                        }, 0));
+                                        if (resolved) {
+                                            edit.additionalEdit = resolved.additionalEdit;
+                                        }
+                                        return resolve(edit);
+                                    }
+                                    catch (err) {
+                                        return reject(err);
+                                    }
+                                })();
+                            }))
+                        );
+                    }, token);
                 }
-                await this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token, clipboardEvent);
+                await this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
             }
             finally {
-                tokenSource.dispose();
+                disposables.dispose();
                 if (this._currentPasteOperation === p) {
                     this._currentPasteOperation = undefined;
                 }
             }
         });
-        this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localizeWithPath(_moduleId, 3, "Running paste handlers. Click to cancel")), p);
+        this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localizeWithPath(_moduleId, 4, "Running paste handlers. Click to cancel and do basic paste")), p, {
+            cancel: async () => {
+                try {
+                    p.cancel();
+                    if (editorStateCts.token.isCancellationRequested) {
+                        return;
+                    }
+                    await this.applyDefaultPasteHandler(dataTransfer, metadata, editorStateCts.token, clipboardEvent);
+                }
+                finally {
+                    editorStateCts.dispose();
+                }
+            }
+        }).then(() => {
+            editorStateCts.dispose();
+        });
         this._currentPasteOperation = p;
     }
     showPasteAsPick(preference, allProviders, selections, dataTransfer, metadata) {
@@ -272,12 +315,13 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 return;
             }
             const model = editor.getModel();
-            const tokenSource = ( (new EditorStateCancellationTokenSource(
+            const disposables = ( (new DisposableStore()));
+            const tokenSource = disposables.add(( (new EditorStateCancellationTokenSource(
                 editor,
                 CodeEditorStateFlag.Value | CodeEditorStateFlag.Selection,
                 undefined,
                 token
-            )));
+            ))));
             try {
                 await this.mergeInDataFromCopy(dataTransfer, metadata, tokenSource.token);
                 if (tokenSource.token.isCancellationRequested) {
@@ -291,21 +335,24 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                     triggerKind: DocumentPasteTriggerKind.PasteAs,
                     only: preference && preference instanceof HierarchicalKind ? preference : undefined,
                 };
-                let providerEdits = 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) {
-                    providerEdits = providerEdits.filter(edit => {
-                        if (preference instanceof HierarchicalKind) {
-                            return preference.contains(edit.kind);
-                        }
-                        else {
-                            return preference.providerId === edit.provider.id;
-                        }
-                    });
+                    editSession = {
+                        edits: editSession.edits.filter(edit => {
+                            if (preference instanceof HierarchicalKind) {
+                                return preference.contains(edit.kind);
+                            }
+                            else {
+                                return preference.providerId === edit.provider.id;
+                            }
+                        }),
+                        dispose: editSession.dispose
+                    };
                 }
-                if (!providerEdits.length) {
+                if (!editSession.edits.length) {
                     if (context.only) {
                         this.showPasteAsNoEditMessage(selections, context.only);
                     }
@@ -313,15 +360,15 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 }
                 let pickedEdit;
                 if (preference) {
-                    pickedEdit = providerEdits.at(0);
+                    pickedEdit = editSession.edits.at(0);
                 }
                 else {
-                    const selected = await this._quickInputService.pick(( (providerEdits.map((edit) => ({
+                    const selected = await this._quickInputService.pick(( (editSession.edits.map((edit) => ({
                         label: edit.title,
                         description: edit.kind?.value,
                         edit,
                     })))), {
-                        placeHolder: ( localizeWithPath(_moduleId, 4, "Select Paste Action")),
+                        placeHolder: ( localizeWithPath(_moduleId, 5, "Select Paste Action")),
                     });
                     pickedEdit = selected?.edit;
                 }
@@ -332,7 +379,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
                 await this._bulkEditService.apply(combinedWorkspaceEdit, { editor: this._editor });
             }
             finally {
-                tokenSource.dispose();
+                disposables.dispose();
                 if (this._currentPasteOperation === p) {
                     this._currentPasteOperation = undefined;
                 }
@@ -340,7 +387,7 @@ let CopyPasteController = class CopyPasteController extends Disposable {
         });
         this._progressService.withProgress({
             location: ProgressLocation.Window,
-            title: ( localizeWithPath(_moduleId, 5, "Running paste handlers")),
+            title: ( localizeWithPath(_moduleId, 6, "Running paste handlers")),
         }, () => p);
     }
     setCopyMetadata(dataTransfer, metadata) {
@@ -392,20 +439,29 @@ 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) => {
             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) {
-                console.error(err);
+                if (!isCancellationError(err)) {
+                    console.error(err);
+                }
+                return undefined;
             }
-            return undefined;
         })))), token);
         const edits = coalesce(results ?? []).flat().filter(edit => {
             return !context.only || context.only.contains(edit.kind);
         });
-        return sortEditsByYieldTo(edits);
+        return {
+            edits: sortEditsByYieldTo(edits),
+            dispose: () => disposables.dispose()
+        };
     }
     async applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent) {
         const textDataTransfer = dataTransfer.get(Mimes.text) ?? dataTransfer.get('text');

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

@@ -19,13 +19,19 @@ class SimplePasteAndDropProvider {
             return undefined;
         }
         return {
+            edits: [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }],
             dispose() { },
-            edits: [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }]
         };
     }
     async provideDocumentDropEdits(_model, _position, dataTransfer, token) {
         const edit = await this.getEdit(dataTransfer, token);
-        return edit ? [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }] : undefined;
+        if (!edit) {
+            return;
+        }
+        return {
+            edits: [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }],
+            dispose() { },
+        };
     }
 }
 class DefaultTextPasteOrDropEditProvider extends SimplePasteAndDropProvider {