@easyv/biz-components 0.0.52-beta.0 → 0.0.52-beta.1

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution.es.js

@@ -0,0 +1,95 @@
+var _a;
+import { HierarchicalKind } from "../../../../base/common/hierarchicalKind.es.js";
+import { registerEditorContribution, registerEditorCommand, EditorCommand, registerEditorAction, EditorAction } from "../../../browser/editorExtensions.es.js";
+import { EditorContextKeys } from "../../../common/editorContextKeys.es.js";
+import { registerEditorFeature } from "../../../common/editorFeatures.es.js";
+import { CopyPasteController, pasteWidgetVisibleCtx, changePasteTypeCommandId } from "./copyPasteController.es.js";
+import { DefaultPasteProvidersFeature, DefaultTextPasteOrDropEditProvider } from "./defaultProviders.es.js";
+import { localize } from "../../../../nls.es.js";
+registerEditorContribution(
+  CopyPasteController.ID,
+  CopyPasteController,
+  0
+  /* EditorContributionInstantiation.Eager */
+);
+registerEditorFeature(DefaultPasteProvidersFeature);
+registerEditorCommand(new class extends EditorCommand {
+  constructor() {
+    super({
+      id: changePasteTypeCommandId,
+      precondition: pasteWidgetVisibleCtx,
+      kbOpts: {
+        weight: 100,
+        primary: 2048 | 89
+      }
+    });
+  }
+  runEditorCommand(_accessor, editor) {
+    var _a2;
+    return (_a2 = CopyPasteController.get(editor)) == null ? void 0 : _a2.changePasteType();
+  }
+}());
+registerEditorCommand(new class extends EditorCommand {
+  constructor() {
+    super({
+      id: "editor.hidePasteWidget",
+      precondition: pasteWidgetVisibleCtx,
+      kbOpts: {
+        weight: 100,
+        primary: 9
+      }
+    });
+  }
+  runEditorCommand(_accessor, editor) {
+    var _a2;
+    (_a2 = CopyPasteController.get(editor)) == null ? void 0 : _a2.clearWidgets();
+  }
+}());
+registerEditorAction((_a = class extends EditorAction {
+  constructor() {
+    super({
+      id: "editor.action.pasteAs",
+      label: localize("pasteAs", "Paste As..."),
+      alias: "Paste As...",
+      precondition: EditorContextKeys.writable,
+      metadata: {
+        description: "Paste as",
+        args: [{
+          name: "args",
+          schema: _a.argsSchema
+        }]
+      }
+    });
+  }
+  run(_accessor, editor, args) {
+    var _a2;
+    let kind = typeof (args == null ? void 0 : args.kind) === "string" ? args.kind : void 0;
+    if (!kind && args) {
+      kind = typeof args.id === "string" ? args.id : void 0;
+    }
+    return (_a2 = CopyPasteController.get(editor)) == null ? void 0 : _a2.pasteAs(kind ? new HierarchicalKind(kind) : void 0);
+  }
+}, _a.argsSchema = {
+  type: "object",
+  properties: {
+    kind: {
+      type: "string",
+      description: localize("pasteAs.kind", "The kind of the paste edit to try applying. If not provided or there are multiple edits for this kind, the editor will show a picker.")
+    }
+  }
+}, _a));
+registerEditorAction(class extends EditorAction {
+  constructor() {
+    super({
+      id: "editor.action.pasteAsText",
+      label: localize("pasteAsText", "Paste as Text"),
+      alias: "Paste as Text",
+      precondition: EditorContextKeys.writable
+    });
+  }
+  run(_accessor, editor) {
+    var _a2;
+    return (_a2 = CopyPasteController.get(editor)) == null ? void 0 : _a2.pasteAs({ providerId: DefaultTextPasteOrDropEditProvider.id });
+  }
+});
+//# sourceMappingURL=copyPasteContribution.es.js.map

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyPasteContribution.es.js","sources":["../../../../../../../../../../../../../../node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';\nimport { EditorAction, EditorCommand, registerEditorAction, registerEditorCommand, registerEditorContribution } from '../../../browser/editorExtensions.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { registerEditorFeature } from '../../../common/editorFeatures.js';\nimport { CopyPasteController, changePasteTypeCommandId, pasteWidgetVisibleCtx } from './copyPasteController.js';\nimport { DefaultPasteProvidersFeature, DefaultTextPasteOrDropEditProvider } from './defaultProviders.js';\nimport * as nls from '../../../../nls.js';\nregisterEditorContribution(CopyPasteController.ID, CopyPasteController, 0 /* EditorContributionInstantiation.Eager */); // eager because it listens to events on the container dom node of the editor\nregisterEditorFeature(DefaultPasteProvidersFeature);\nregisterEditorCommand(new class extends EditorCommand {\n    constructor() {\n        super({\n            id: changePasteTypeCommandId,\n            precondition: pasteWidgetVisibleCtx,\n            kbOpts: {\n                weight: 100 /* KeybindingWeight.EditorContrib */,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */,\n            }\n        });\n    }\n    runEditorCommand(_accessor, editor) {\n        return CopyPasteController.get(editor)?.changePasteType();\n    }\n});\nregisterEditorCommand(new class extends EditorCommand {\n    constructor() {\n        super({\n            id: 'editor.hidePasteWidget',\n            precondition: pasteWidgetVisibleCtx,\n            kbOpts: {\n                weight: 100 /* KeybindingWeight.EditorContrib */,\n                primary: 9 /* KeyCode.Escape */,\n            }\n        });\n    }\n    runEditorCommand(_accessor, editor) {\n        CopyPasteController.get(editor)?.clearWidgets();\n    }\n});\nregisterEditorAction(class PasteAsAction extends EditorAction {\n    static { this.argsSchema = {\n        type: 'object',\n        properties: {\n            kind: {\n                type: 'string',\n                description: nls.localize('pasteAs.kind', \"The kind of the paste edit to try applying. If not provided or there are multiple edits for this kind, the editor will show a picker.\"),\n            }\n        },\n    }; }\n    constructor() {\n        super({\n            id: 'editor.action.pasteAs',\n            label: nls.localize('pasteAs', \"Paste As...\"),\n            alias: 'Paste As...',\n            precondition: EditorContextKeys.writable,\n            metadata: {\n                description: 'Paste as',\n                args: [{\n                        name: 'args',\n                        schema: PasteAsAction.argsSchema\n                    }]\n            }\n        });\n    }\n    run(_accessor, editor, args) {\n        let kind = typeof args?.kind === 'string' ? args.kind : undefined;\n        if (!kind && args) {\n            // Support old id property\n            // TODO: remove this in the future\n            kind = typeof args.id === 'string' ? args.id : undefined;\n        }\n        return CopyPasteController.get(editor)?.pasteAs(kind ? new HierarchicalKind(kind) : undefined);\n    }\n});\nregisterEditorAction(class extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.pasteAsText',\n            label: nls.localize('pasteAsText', \"Paste as Text\"),\n            alias: 'Paste as Text',\n            precondition: EditorContextKeys.writable,\n        });\n    }\n    run(_accessor, editor) {\n        return CopyPasteController.get(editor)?.pasteAs({ providerId: DefaultTextPasteOrDropEditProvider.id });\n    }\n});\n"],"names":["_a","nls.localize"],"mappings":";;;;;;;;AAWA;AAAA,EAA2B,oBAAoB;AAAA,EAAI;AAAA,EAAqB;AAAA;AAAC;AACzE,sBAAsB,4BAA4B;AAClD,sBAAsB,IAAI,cAAc,cAAc;AAAA,EAClD,cAAc;AACV,UAAM;AAAA,MACF,IAAI;AAAA,MACJ,cAAc;AAAA,MACd,QAAQ;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,OAA4B;AAAA,MACrD;AAAA,IACA,CAAS;AAAA,EACT;AAAA,EACI,iBAAiB,WAAW,QAAQ;;AAChC,YAAOA,MAAA,oBAAoB,IAAI,MAAM,MAA9B,gBAAAA,IAAiC;AAAA,EAChD;AACA,GAAC;AACD,sBAAsB,IAAI,cAAc,cAAc;AAAA,EAClD,cAAc;AACV,UAAM;AAAA,MACF,IAAI;AAAA,MACJ,cAAc;AAAA,MACd,QAAQ;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS;AAAA,MACzB;AAAA,IACA,CAAS;AAAA,EACT;AAAA,EACI,iBAAiB,WAAW,QAAQ;;AAChC,KAAAA,MAAA,oBAAoB,IAAI,MAAM,MAA9B,gBAAAA,IAAiC;AAAA,EACzC;AACA,GAAC;AACD,sBAAqB,mBAA4B,aAAa;AAAA,EAU1D,cAAc;AACV,UAAM;AAAA,MACF,IAAI;AAAA,MACJ,OAAOC,SAAa,WAAW,aAAa;AAAA,MAC5C,OAAO;AAAA,MACP,cAAc,kBAAkB;AAAA,MAChC,UAAU;AAAA,QACN,aAAa;AAAA,QACb,MAAM,CAAC;AAAA,UACC,MAAM;AAAA,UACN,QAAQ,GAAc;AAAA,QACzB,CAAA;AAAA,MACrB;AAAA,IACA,CAAS;AAAA,EACT;AAAA,EACI,IAAI,WAAW,QAAQ,MAAM;;AACzB,QAAI,OAAO,QAAO,6BAAM,UAAS,WAAW,KAAK,OAAO;AACxD,QAAI,CAAC,QAAQ,MAAM;AAGf,aAAO,OAAO,KAAK,OAAO,WAAW,KAAK,KAAK;AAAA,IAC3D;AACQ,YAAOD,MAAA,oBAAoB,IAAI,MAAM,MAA9B,gBAAAA,IAAiC,QAAQ,OAAO,IAAI,iBAAiB,IAAI,IAAI;AAAA,EAC5F;AACA,GAjCa,GAAK,aAAa;AAAA,EACvB,MAAM;AAAA,EACN,YAAY;AAAA,IACR,MAAM;AAAA,MACF,MAAM;AAAA,MACN,aAAaC,SAAa,gBAAgB,uIAAuI;AAAA,IACjM;AAAA,EACS;AACT,GATqB,GAkCpB;AACD,qBAAqB,cAAc,aAAa;AAAA,EAC5C,cAAc;AACV,UAAM;AAAA,MACF,IAAI;AAAA,MACJ,OAAOA,SAAa,eAAe,eAAe;AAAA,MAClD,OAAO;AAAA,MACP,cAAc,kBAAkB;AAAA,IAC5C,CAAS;AAAA,EACT;AAAA,EACI,IAAI,WAAW,QAAQ;;AACnB,YAAOD,MAAA,oBAAoB,IAAI,MAAM,MAA9B,gBAAAA,IAAiC,QAAQ,EAAE,YAAY,mCAAmC;EACzG;AACA,CAAC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController.es.js

@@ -0,0 +1,504 @@
+var _a;
+import { addDisposableListener, getActiveDocument } from "../../../../base/browser/dom.es.js";
+import { coalesce } from "../../../../base/common/arrays.es.js";
+import { createCancelablePromise, DeferredPromise, raceCancellation } from "../../../../base/common/async.es.js";
+import { CancellationTokenSource } from "../../../../base/common/cancellation.es.js";
+import { matchesMimeType, createStringDataTransferItem, UriList } from "../../../../base/common/dataTransfer.es.js";
+import { HierarchicalKind } from "../../../../base/common/hierarchicalKind.es.js";
+import { Disposable, DisposableStore } from "../../../../base/common/lifecycle.es.js";
+import { Mimes } from "../../../../base/common/mime.es.js";
+import { isWindows } from "../../../../base/common/platform.es.js";
+import { generateUuid } from "../../../../base/common/uuid.es.js";
+import { ClipboardEventUtils } from "../../../browser/controller/textAreaInput.es.js";
+import { toVSDataTransfer, toExternalVSDataTransfer } from "../../../browser/dnd.es.js";
+import { IBulkEditService } from "../../../browser/services/bulkEditService.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { DocumentPasteTriggerKind } from "../../../common/languages.es.js";
+import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.es.js";
+import { DefaultTextPasteOrDropEditProvider } from "./defaultProviders.es.js";
+import { createCombinedWorkspaceEdit, sortEditsByYieldTo } from "./edit.es.js";
+import { EditorStateCancellationTokenSource } from "../../editorState/browser/editorState.es.js";
+import { InlineProgressManager } from "../../inlineProgress/browser/inlineProgress.es.js";
+import { MessageController } from "../../message/browser/messageController.es.js";
+import { localize } from "../../../../nls.es.js";
+import { IClipboardService } from "../../../../platform/clipboard/common/clipboardService.es.js";
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.es.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.es.js";
+import { IProgressService } from "../../../../platform/progress/common/progress.es.js";
+import { IQuickInputService } from "../../../../platform/quickinput/common/quickInput.es.js";
+import { PostEditWidgetManager } from "./postEditWidget.es.js";
+import { CancellationError, isCancellationError } from "../../../../base/common/errors.es.js";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+var CopyPasteController_1;
+const changePasteTypeCommandId = "editor.changePasteType";
+const pasteWidgetVisibleCtx = new RawContextKey("pasteWidgetVisible", false, localize("pasteWidgetVisible", "Whether the paste widget is showing"));
+const vscodeClipboardMime = "application/vnd.code.copyMetadata";
+let CopyPasteController = (_a = class extends Disposable {
+  static get(editor) {
+    return editor.getContribution(CopyPasteController_1.ID);
+  }
+  constructor(editor, instantiationService, _bulkEditService, _clipboardService, _languageFeaturesService, _quickInputService, _progressService) {
+    super();
+    this._bulkEditService = _bulkEditService;
+    this._clipboardService = _clipboardService;
+    this._languageFeaturesService = _languageFeaturesService;
+    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("postPasteWidgetTitle", "Show paste options...") }));
+  }
+  changePasteType() {
+    this._postPasteWidgetManager.tryShowSelector();
+  }
+  pasteAs(preferred) {
+    this._editor.focus();
+    try {
+      this._pasteAsActionContext = { preferred };
+      getActiveDocument().execCommand("paste");
+    } finally {
+      this._pasteAsActionContext = void 0;
+    }
+  }
+  clearWidgets() {
+    this._postPasteWidgetManager.clear();
+  }
+  isPasteAsEnabled() {
+    return this._editor.getOption(
+      85
+      /* EditorOption.pasteAs */
+    ).enabled;
+  }
+  async finishedPaste() {
+    await this._currentPasteOperation;
+  }
+  handleCopy(e) {
+    var _a2, _b, _c, _d;
+    if (!this._editor.hasTextFocus()) {
+      return;
+    }
+    (_b = (_a2 = this._clipboardService).clearInternalState) == null ? void 0 : _b.call(_a2);
+    if (!e.clipboardData || !this.isPasteAsEnabled()) {
+      return;
+    }
+    const model = this._editor.getModel();
+    const selections = this._editor.getSelections();
+    if (!model || !(selections == null ? void 0 : selections.length)) {
+      return;
+    }
+    const enableEmptySelectionClipboard = this._editor.getOption(
+      37
+      /* 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 = (_c = this._editor._getViewModel()) == null ? void 0 : _c.getPlainTextToCopy(selections, enableEmptySelectionClipboard, isWindows);
+    const multicursorText = Array.isArray(toCopy) ? toCopy : null;
+    const defaultPastePayload = {
+      multicursorText,
+      pasteOnNewLine: wasFromEmptySelection,
+      mode: null
+    };
+    const providers = this._languageFeaturesService.documentPasteEditProvider.ordered(model).filter((x) => !!x.prepareDocumentPaste);
+    if (!providers.length) {
+      this.setCopyMetadata(e.clipboardData, { defaultPastePayload });
+      return;
+    }
+    const dataTransfer = toVSDataTransfer(e.clipboardData);
+    const providerCopyMimeTypes = providers.flatMap((x) => x.copyMimeTypes ?? []);
+    const handle = generateUuid();
+    this.setCopyMetadata(e.clipboardData, {
+      id: handle,
+      providerCopyMimeTypes,
+      defaultPastePayload
+    });
+    const promise = createCancelablePromise(async (token) => {
+      const results = coalesce(await Promise.all(providers.map(async (provider) => {
+        try {
+          return await provider.prepareDocumentPaste(model, ranges, dataTransfer, token);
+        } catch (err) {
+          console.error(err);
+          return void 0;
+        }
+      })));
+      results.reverse();
+      for (const result of results) {
+        for (const [mime, value] of result) {
+          dataTransfer.replace(mime, value);
+        }
+      }
+      return dataTransfer;
+    });
+    (_d = CopyPasteController_1._currentCopyOperation) == null ? void 0 : _d.dataTransferPromise.cancel();
+    CopyPasteController_1._currentCopyOperation = { handle, dataTransferPromise: promise };
+  }
+  async handlePaste(e) {
+    var _a2, _b, _c;
+    if (!e.clipboardData || !this._editor.hasTextFocus()) {
+      return;
+    }
+    (_a2 = MessageController.get(this._editor)) == null ? void 0 : _a2.closeMessage();
+    (_b = this._currentPasteOperation) == null ? void 0 : _b.cancel();
+    this._currentPasteOperation = void 0;
+    const model = this._editor.getModel();
+    const selections = this._editor.getSelections();
+    if (!(selections == null ? void 0 : selections.length) || !model) {
+      return;
+    }
+    if (this._editor.getOption(
+      92
+      /* EditorOption.readOnly */
+    ) || !this.isPasteAsEnabled() && !this._pasteAsActionContext) {
+      return;
+    }
+    const metadata = this.fetchCopyMetadata(e);
+    const dataTransfer = toExternalVSDataTransfer(e.clipboardData);
+    dataTransfer.delete(vscodeClipboardMime);
+    const allPotentialMimeTypes = [
+      ...e.clipboardData.types,
+      ...(metadata == null ? void 0 : metadata.providerCopyMimeTypes) ?? [],
+      // TODO: always adds `uri-list` because this get set if there are resources in the system clipboard.
+      // However we can only check the system clipboard async. For this early check, just add it in.
+      // We filter providers again once we have the final dataTransfer we will use.
+      Mimes.uriList
+    ];
+    const allProviders = this._languageFeaturesService.documentPasteEditProvider.ordered(model).filter((provider) => {
+      var _a3, _b2;
+      const preference = (_a3 = this._pasteAsActionContext) == null ? void 0 : _a3.preferred;
+      if (preference) {
+        if (provider.providedPasteEditKinds && !this.providerMatchesPreference(provider, preference)) {
+          return false;
+        }
+      }
+      return (_b2 = provider.pasteMimeTypes) == null ? void 0 : _b2.some((type) => matchesMimeType(type, allPotentialMimeTypes));
+    });
+    if (!allProviders.length) {
+      if ((_c = this._pasteAsActionContext) == null ? void 0 : _c.preferred) {
+        this.showPasteAsNoEditMessage(selections, this._pasteAsActionContext.preferred);
+      }
+      return;
+    }
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    if (this._pasteAsActionContext) {
+      this.showPasteAsPick(this._pasteAsActionContext.preferred, allProviders, selections, dataTransfer, metadata);
+    } else {
+      this.doPasteInline(allProviders, selections, dataTransfer, metadata, e);
+    }
+  }
+  showPasteAsNoEditMessage(selections, preference) {
+    var _a2;
+    (_a2 = MessageController.get(this._editor)) == null ? void 0 : _a2.showMessage(localize("pasteAsError", "No paste edits for '{0}' found", preference instanceof HierarchicalKind ? preference.value : preference.providerId), selections[0].getStartPosition());
+  }
+  doPasteInline(allProviders, selections, dataTransfer, metadata, clipboardEvent) {
+    const editor = this._editor;
+    if (!editor.hasModel()) {
+      return;
+    }
+    const editorStateCts = new EditorStateCancellationTokenSource(editor, 1 | 2, void 0);
+    const p = createCancelablePromise(async (pToken) => {
+      const editor2 = this._editor;
+      if (!editor2.hasModel()) {
+        return;
+      }
+      const model = editor2.getModel();
+      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, 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, token, clipboardEvent);
+        }
+        const context = {
+          triggerKind: DocumentPasteTriggerKind.Automatic
+        };
+        const editSession = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, context, token);
+        disposables.add(editSession);
+        if (token.isCancellationRequested) {
+          return;
+        }
+        if (editSession.edits.length === 1 && editSession.edits[0].provider instanceof DefaultTextPasteOrDropEditProvider) {
+          return this.applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent);
+        }
+        if (editSession.edits.length) {
+          const canShowWidget = editor2.getOption(
+            85
+            /* EditorOption.pasteAs */
+          ).showPasteSelector === "afterPaste";
+          return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, { activeEditIndex: 0, allEdits: editSession.edits }, canShowWidget, (edit, token2) => {
+            return new Promise((resolve, reject) => {
+              (async () => {
+                var _a2, _b;
+                try {
+                  const resolveP = (_b = (_a2 = edit.provider).resolveDocumentPasteEdit) == null ? void 0 : _b.call(_a2, edit, token2);
+                  const showP = new DeferredPromise();
+                  const resolved = resolveP && await this._pasteProgressManager.showWhile(selections[0].getEndPosition(), localize("resolveProcess", "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, token, clipboardEvent);
+      } finally {
+        disposables.dispose();
+        if (this._currentPasteOperation === p) {
+          this._currentPasteOperation = void 0;
+        }
+      }
+    });
+    this._pasteProgressManager.showWhile(selections[0].getEndPosition(), localize("pasteIntoEditorProgress", "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) {
+    const p = createCancelablePromise(async (token) => {
+      const editor = this._editor;
+      if (!editor.hasModel()) {
+        return;
+      }
+      const model = editor.getModel();
+      const disposables = new DisposableStore();
+      const tokenSource = disposables.add(new EditorStateCancellationTokenSource(editor, 1 | 2, void 0, token));
+      try {
+        await this.mergeInDataFromCopy(dataTransfer, metadata, tokenSource.token);
+        if (tokenSource.token.isCancellationRequested) {
+          return;
+        }
+        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 && preference instanceof HierarchicalKind ? preference : void 0
+        };
+        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 (preference instanceof HierarchicalKind) {
+                return preference.contains(edit.kind);
+              } else {
+                return preference.providerId === edit.provider.id;
+              }
+            }),
+            dispose: editSession.dispose
+          };
+        }
+        if (!editSession.edits.length) {
+          if (context.only) {
+            this.showPasteAsNoEditMessage(selections, context.only);
+          }
+          return;
+        }
+        let pickedEdit;
+        if (preference) {
+          pickedEdit = editSession.edits.at(0);
+        } else {
+          const selected = await this._quickInputService.pick(editSession.edits.map((edit) => {
+            var _a2;
+            return {
+              label: edit.title,
+              description: (_a2 = edit.kind) == null ? void 0 : _a2.value,
+              edit
+            };
+          }), {
+            placeHolder: localize("pasteAsPickerPlaceholder", "Select Paste Action")
+          });
+          pickedEdit = selected == null ? void 0 : selected.edit;
+        }
+        if (!pickedEdit) {
+          return;
+        }
+        const combinedWorkspaceEdit = createCombinedWorkspaceEdit(model.uri, selections, pickedEdit);
+        await this._bulkEditService.apply(combinedWorkspaceEdit, { editor: this._editor });
+      } finally {
+        disposables.dispose();
+        if (this._currentPasteOperation === p) {
+          this._currentPasteOperation = void 0;
+        }
+      }
+    });
+    this._progressService.withProgress({
+      location: 10,
+      title: localize("pasteAsProgress", "Running paste handlers")
+    }, () => p);
+  }
+  setCopyMetadata(dataTransfer, metadata) {
+    dataTransfer.setData(vscodeClipboardMime, JSON.stringify(metadata));
+  }
+  fetchCopyMetadata(e) {
+    if (!e.clipboardData) {
+      return;
+    }
+    const rawMetadata = e.clipboardData.getData(vscodeClipboardMime);
+    if (rawMetadata) {
+      try {
+        return JSON.parse(rawMetadata);
+      } catch {
+        return void 0;
+      }
+    }
+    const [_, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
+    if (metadata) {
+      return {
+        defaultPastePayload: {
+          mode: metadata.mode,
+          multicursorText: metadata.multicursorText ?? null,
+          pasteOnNewLine: !!metadata.isFromEmptySelection
+        }
+      };
+    }
+    return void 0;
+  }
+  async mergeInDataFromCopy(dataTransfer, metadata, token) {
+    var _a2;
+    if ((metadata == null ? void 0 : metadata.id) && ((_a2 = CopyPasteController_1._currentCopyOperation) == null ? void 0 : _a2.handle) === metadata.id) {
+      const toMergeDataTransfer = await CopyPasteController_1._currentCopyOperation.dataTransferPromise;
+      if (token.isCancellationRequested) {
+        return;
+      }
+      for (const [key, value] of toMergeDataTransfer) {
+        dataTransfer.replace(key, value);
+      }
+    }
+    if (!dataTransfer.has(Mimes.uriList)) {
+      const resources = await this._clipboardService.readResources();
+      if (token.isCancellationRequested) {
+        return;
+      }
+      if (resources.length) {
+        dataTransfer.append(Mimes.uriList, createStringDataTransferItem(UriList.create(resources)));
+      }
+    }
+  }
+  async getPasteEdits(providers, dataTransfer, model, selections, context, token) {
+    const disposables = new DisposableStore();
+    const results = await raceCancellation(Promise.all(providers.map(async (provider) => {
+      var _a2, _b;
+      try {
+        const edits2 = await ((_a2 = provider.provideDocumentPasteEdits) == null ? void 0 : _a2.call(provider, model, selections, dataTransfer, context, token));
+        if (edits2) {
+          disposables.add(edits2);
+        }
+        return (_b = edits2 == null ? void 0 : edits2.edits) == null ? void 0 : _b.map((edit) => ({ ...edit, provider }));
+      } catch (err) {
+        if (!isCancellationError(err)) {
+          console.error(err);
+        }
+        return void 0;
+      }
+    })), token);
+    const edits = coalesce(results ?? []).flat().filter((edit) => {
+      return !context.only || context.only.contains(edit.kind);
+    });
+    return {
+      edits: sortEditsByYieldTo(edits),
+      dispose: () => disposables.dispose()
+    };
+  }
+  async applyDefaultPasteHandler(dataTransfer, metadata, token, clipboardEvent) {
+    const textDataTransfer = dataTransfer.get(Mimes.text) ?? dataTransfer.get("text");
+    const text = await (textDataTransfer == null ? void 0 : textDataTransfer.asString()) ?? "";
+    if (token.isCancellationRequested) {
+      return;
+    }
+    const payload = {
+      clipboardEvent,
+      text,
+      pasteOnNewLine: (metadata == null ? void 0 : metadata.defaultPastePayload.pasteOnNewLine) ?? false,
+      multicursorText: (metadata == null ? void 0 : metadata.defaultPastePayload.multicursorText) ?? null,
+      mode: null
+    };
+    this._editor.trigger("keyboard", "paste", payload);
+  }
+  /**
+   * Filter out providers if they:
+   * - Don't handle any of the data transfer types we have
+   * - Don't match the preferred paste kind
+   */
+  isSupportedPasteProvider(provider, dataTransfer, preference) {
+    var _a2;
+    if (!((_a2 = provider.pasteMimeTypes) == null ? void 0 : _a2.some((type) => dataTransfer.matches(type)))) {
+      return false;
+    }
+    return !preference || this.providerMatchesPreference(provider, preference);
+  }
+  providerMatchesPreference(provider, preference) {
+    if (preference instanceof HierarchicalKind) {
+      if (!provider.providedPasteEditKinds) {
+        return true;
+      }
+      return provider.providedPasteEditKinds.some((providedKind) => preference.contains(providedKind));
+    } else {
+      return provider.id === preference.providerId;
+    }
+  }
+}, CopyPasteController_1 = _a, _a.ID = "editor.contrib.copyPasteActionController", _a);
+CopyPasteController = CopyPasteController_1 = __decorate([
+  __param(1, IInstantiationService),
+  __param(2, IBulkEditService),
+  __param(3, IClipboardService),
+  __param(4, ILanguageFeaturesService),
+  __param(5, IQuickInputService),
+  __param(6, IProgressService)
+], CopyPasteController);
+export {
+  CopyPasteController,
+  changePasteTypeCommandId,
+  pasteWidgetVisibleCtx
+};
+//# sourceMappingURL=copyPasteController.es.js.map