@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

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

@@ -0,0 +1,59 @@
+import { registerEditorContribution, registerEditorCommand, EditorCommand, registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { registerEditorFeature } from '../../../common/editorFeatures.js';
+import { changePasteTypeCommandId, pasteWidgetVisibleCtx, CopyPasteController } from './copyPasteController.js';
+import { DefaultPasteProvidersFeature } from './defaultProviders.js';
+import { localizeWithPath } from '../../../../nls.js';
+registerEditorContribution(CopyPasteController.ID, CopyPasteController, 0 );
+registerEditorFeature(DefaultPasteProvidersFeature);
+registerEditorCommand(new (class extends EditorCommand {
+    constructor() {
+        super({
+            id: changePasteTypeCommandId,
+            precondition: pasteWidgetVisibleCtx,
+            kbOpts: {
+                weight: 100 ,
+                primary: 2048  | 89 ,
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, _args) {
+        return CopyPasteController.get(editor)?.changePasteType();
+    }
+}));
+registerEditorAction(class extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.pasteAs',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution',
+                'pasteAs',
+                "Paste As..."
+            )),
+            alias: 'Paste As...',
+            precondition: undefined,
+            metadata: {
+                description: 'Paste as',
+                args: [{
+                        name: 'args',
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                'id': {
+                                    type: 'string',
+                                    description: ( localizeWithPath(
+                                        'vs/editor/contrib/dropOrPasteInto/browser/copyPasteContribution',
+                                        'pasteAs.id',
+                                        "The id of the paste edit to try applying. If not provided, the editor will show a picker."
+                                    )),
+                                }
+                            },
+                        }
+                    }]
+            }
+        });
+    }
+    run(_accessor, editor, args) {
+        const id = typeof args?.id === 'string' ? args.id : undefined;
+        return CopyPasteController.get(editor)?.pasteAs(id);
+    }
+});

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

@@ -0,0 +1,403 @@
+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 { matchesMimeType, createStringDataTransferItem, UriList } from '../../../../base/common/dataTransfer.js';
+import { Disposable } 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';
+import { ClipboardEventUtils } from '../../../browser/controller/textAreaInput.js';
+import { toVSDataTransfer, toExternalVSDataTransfer } from '../../../browser/dnd.js';
+import { IBulkEditService } from '../../../browser/services/bulkEditService.js';
+import { Range } from '../../../common/core/range.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { sortEditsByYieldTo, createCombinedWorkspaceEdit } from './edit.js';
+import { EditorStateCancellationTokenSource } from '../../editorState/browser/editorState.js';
+import { InlineProgressManager } from '../../inlineProgress/browser/inlineProgress.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IClipboardService } from '../../../../platform/clipboard/common/clipboardService.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
+import { PostEditWidgetManager } from './postEditWidget.js';
+var CopyPasteController_1;
+const changePasteTypeCommandId = 'editor.changePasteType';
+const pasteWidgetVisibleCtx = ( new RawContextKey('pasteWidgetVisible', false, ( localizeWithPath(
+    'vs/editor/contrib/dropOrPasteInto/browser/copyPasteController',
+    'pasteWidgetVisible',
+    "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 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: ( localizeWithPath(
+            'vs/editor/contrib/dropOrPasteInto/browser/copyPasteController',
+            'postPasteWidgetTitle',
+            "Show paste options..."
+        )) }));
+    }
+    changePasteType() {
+        this._postPasteWidgetManager.tryShowSelector();
+    }
+    pasteAs(preferredId) {
+        this._editor.focus();
+        try {
+            this._pasteAsActionContext = { preferredId };
+            getActiveDocument().execCommand('paste');
+        }
+        finally {
+            this._pasteAsActionContext = undefined;
+        }
+    }
+    clearWidgets() {
+        this._postPasteWidgetManager.clear();
+    }
+    isPasteAsEnabled() {
+        return this._editor.getOption(84 ).enabled
+            && !this._editor.getOption(90 );
+    }
+    handleCopy(e) {
+        if (!this._editor.hasTextFocus()) {
+            return;
+        }
+        if (isWeb) {
+            this._clipboardService.writeResources([]);
+        }
+        if (!e.clipboardData || !this.isPasteAsEnabled()) {
+            return;
+        }
+        const model = this._editor.getModel();
+        const selections = this._editor.getSelections();
+        if (!model || !selections?.length) {
+            return;
+        }
+        const enableEmptySelectionClipboard = this._editor.getOption(37 );
+        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,
+            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 undefined;
+                }
+            }))));
+            results.reverse();
+            for (const result of results) {
+                for (const [mime, value] of result) {
+                    dataTransfer.replace(mime, value);
+                }
+            }
+            return dataTransfer;
+        });
+        this._currentCopyOperation?.dataTransferPromise.cancel();
+        this._currentCopyOperation = { handle: handle, dataTransferPromise: promise };
+    }
+    async handlePaste(e) {
+        if (!e.clipboardData || !this._editor.hasTextFocus()) {
+            return;
+        }
+        this._currentPasteOperation?.cancel();
+        this._currentPasteOperation = undefined;
+        const model = this._editor.getModel();
+        const selections = this._editor.getSelections();
+        if (!selections?.length || !model) {
+            return;
+        }
+        if (!this.isPasteAsEnabled()) {
+            return;
+        }
+        const metadata = this.fetchCopyMetadata(e);
+        const dataTransfer = toExternalVSDataTransfer(e.clipboardData);
+        dataTransfer.delete(vscodeClipboardMime);
+        const allPotentialMimeTypes = [
+            ...e.clipboardData.types,
+            ...(metadata?.providerCopyMimeTypes ?? []),
+            Mimes.uriList,
+        ];
+        const allProviders = this._languageFeaturesService.documentPasteEditProvider
+            .ordered(model)
+            .filter(provider => provider.pasteMimeTypes?.some(type => matchesMimeType(type, allPotentialMimeTypes)));
+        if (!allProviders.length) {
+            return;
+        }
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        if (this._pasteAsActionContext) {
+            this.showPasteAsPick(this._pasteAsActionContext.preferredId, allProviders, selections, dataTransfer, metadata);
+        }
+        else {
+            this.doPasteInline(allProviders, selections, dataTransfer, metadata);
+        }
+    }
+    doPasteInline(allProviders, selections, dataTransfer, metadata) {
+        const p = createCancelablePromise(async (token) => {
+            const editor = this._editor;
+            if (!editor.hasModel()) {
+                return;
+            }
+            const model = editor.getModel();
+            const tokenSource = ( new EditorStateCancellationTokenSource(
+                editor,
+                1  | 2 ,
+                undefined,
+                token
+            ));
+            try {
+                await this.mergeInDataFromCopy(dataTransfer, metadata, tokenSource.token);
+                if (tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                const supportedProviders = allProviders.filter(provider => isSupportedPasteProvider(provider, dataTransfer));
+                if (!supportedProviders.length
+                    || (supportedProviders.length === 1 && supportedProviders[0].id === 'text')
+                ) {
+                    await this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token);
+                    return;
+                }
+                const providerEdits = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, tokenSource.token);
+                if (tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                if (providerEdits.length === 1 && providerEdits[0].providerId === 'text') {
+                    await this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token);
+                    return;
+                }
+                if (providerEdits.length) {
+                    const canShowWidget = editor.getOption(84 ).showPasteSelector === 'afterPaste';
+                    return this._postPasteWidgetManager.applyEditAndShowIfNeeded(selections, { activeEditIndex: 0, allEdits: providerEdits }, canShowWidget, tokenSource.token);
+                }
+                await this.applyDefaultPasteHandler(dataTransfer, metadata, tokenSource.token);
+            }
+            finally {
+                tokenSource.dispose();
+                if (this._currentPasteOperation === p) {
+                    this._currentPasteOperation = undefined;
+                }
+            }
+        });
+        this._pasteProgressManager.showWhile(selections[0].getEndPosition(), ( localizeWithPath(
+            'vs/editor/contrib/dropOrPasteInto/browser/copyPasteController',
+            'pasteIntoEditorProgress',
+            "Running paste handlers. Click to cancel"
+        )), p);
+        this._currentPasteOperation = p;
+    }
+    showPasteAsPick(preferredId, allProviders, selections, dataTransfer, metadata) {
+        const p = createCancelablePromise(async (token) => {
+            const editor = this._editor;
+            if (!editor.hasModel()) {
+                return;
+            }
+            const model = editor.getModel();
+            const tokenSource = ( new EditorStateCancellationTokenSource(
+                editor,
+                1  | 2 ,
+                undefined,
+                token
+            ));
+            try {
+                await this.mergeInDataFromCopy(dataTransfer, metadata, tokenSource.token);
+                if (tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                let supportedProviders = allProviders.filter(provider => isSupportedPasteProvider(provider, dataTransfer));
+                if (preferredId) {
+                    supportedProviders = supportedProviders.filter(edit => edit.id === preferredId);
+                }
+                const providerEdits = await this.getPasteEdits(supportedProviders, dataTransfer, model, selections, tokenSource.token);
+                if (tokenSource.token.isCancellationRequested) {
+                    return;
+                }
+                if (!providerEdits.length) {
+                    return;
+                }
+                let pickedEdit;
+                if (preferredId) {
+                    pickedEdit = providerEdits.at(0);
+                }
+                else {
+                    const selected = await this._quickInputService.pick(( providerEdits.map((edit) => ({
+                        label: edit.label,
+                        description: edit.providerId,
+                        detail: edit.detail,
+                        edit,
+                    }))), {
+                        placeHolder: ( localizeWithPath(
+                            'vs/editor/contrib/dropOrPasteInto/browser/copyPasteController',
+                            'pasteAsPickerPlaceholder',
+                            "Select Paste Action"
+                        )),
+                    });
+                    pickedEdit = selected?.edit;
+                }
+                if (!pickedEdit) {
+                    return;
+                }
+                const combinedWorkspaceEdit = createCombinedWorkspaceEdit(model.uri, selections, pickedEdit);
+                await this._bulkEditService.apply(combinedWorkspaceEdit, { editor: this._editor });
+            }
+            finally {
+                tokenSource.dispose();
+                if (this._currentPasteOperation === p) {
+                    this._currentPasteOperation = undefined;
+                }
+            }
+        });
+        this._progressService.withProgress({
+            location: 10 ,
+            title: ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/copyPasteController',
+                '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 undefined;
+            }
+        }
+        const [_, metadata] = ClipboardEventUtils.getTextData(e.clipboardData);
+        if (metadata) {
+            return {
+                defaultPastePayload: {
+                    mode: metadata.mode,
+                    multicursorText: metadata.multicursorText ?? null,
+                    pasteOnNewLine: !!metadata.isFromEmptySelection,
+                },
+            };
+        }
+        return undefined;
+    }
+    async mergeInDataFromCopy(dataTransfer, metadata, token) {
+        if (metadata?.id && this._currentCopyOperation?.handle === metadata.id) {
+            const toMergeDataTransfer = await this._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, token) {
+        const results = await raceCancellation(Promise.all(( providers.map(async (provider) => {
+            try {
+                const edit = await provider.provideDocumentPasteEdits?.(model, selections, dataTransfer, token);
+                if (edit) {
+                    return { ...edit, providerId: provider.id };
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+            return undefined;
+        }))), token);
+        const edits = coalesce(results ?? []);
+        return sortEditsByYieldTo(edits);
+    }
+    async applyDefaultPasteHandler(dataTransfer, metadata, token) {
+        const textDataTransfer = dataTransfer.get(Mimes.text) ?? dataTransfer.get('text');
+        if (!textDataTransfer) {
+            return;
+        }
+        const text = await textDataTransfer.asString();
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const payload = {
+            text,
+            pasteOnNewLine: metadata?.defaultPastePayload.pasteOnNewLine ?? false,
+            multicursorText: metadata?.defaultPastePayload.multicursorText ?? null,
+            mode: null,
+        };
+        this._editor.trigger('keyboard', "paste" , payload);
+    }
+};
+CopyPasteController = CopyPasteController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IBulkEditService)),
+    ( __param(3, IClipboardService)),
+    ( __param(4, ILanguageFeaturesService)),
+    ( __param(5, IQuickInputService)),
+    ( __param(6, IProgressService))
+], CopyPasteController));
+function isSupportedPasteProvider(provider, dataTransfer) {
+    return Boolean(provider.pasteMimeTypes?.some(type => dataTransfer.matches(type)));
+}
+export { CopyPasteController, changePasteTypeCommandId, pasteWidgetVisibleCtx };

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

@@ -0,0 +1,195 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { UriList } from '../../../../base/common/dataTransfer.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Mimes } from '../../../../base/common/mime.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { relativePath } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+const builtInLabel = ( localizeWithPath(
+    'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+    'builtIn',
+    'Built-in'
+));
+class SimplePasteAndDropProvider {
+    async provideDocumentPasteEdits(_model, _ranges, dataTransfer, token) {
+        const edit = await this.getEdit(dataTransfer, token);
+        return edit ? { insertText: edit.insertText, label: edit.label, detail: edit.detail, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo } : undefined;
+    }
+    async provideDocumentOnDropEdits(_model, _position, dataTransfer, token) {
+        const edit = await this.getEdit(dataTransfer, token);
+        return edit ? { insertText: edit.insertText, label: edit.label, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo } : undefined;
+    }
+}
+class DefaultTextProvider extends SimplePasteAndDropProvider {
+    constructor() {
+        super(...arguments);
+        this.id = 'text';
+        this.dropMimeTypes = [Mimes.text];
+        this.pasteMimeTypes = [Mimes.text];
+    }
+    async getEdit(dataTransfer, _token) {
+        const textEntry = dataTransfer.get(Mimes.text);
+        if (!textEntry) {
+            return;
+        }
+        if (( dataTransfer.has(Mimes.uriList))) {
+            return;
+        }
+        const insertText = await textEntry.asString();
+        return {
+            handledMimeType: Mimes.text,
+            label: ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'text.label',
+                "Insert Plain Text"
+            )),
+            detail: builtInLabel,
+            insertText
+        };
+    }
+}
+class PathProvider extends SimplePasteAndDropProvider {
+    constructor() {
+        super(...arguments);
+        this.id = 'uri';
+        this.dropMimeTypes = [Mimes.uriList];
+        this.pasteMimeTypes = [Mimes.uriList];
+    }
+    async getEdit(dataTransfer, token) {
+        const entries = await extractUriList(dataTransfer);
+        if (!entries.length || token.isCancellationRequested) {
+            return;
+        }
+        let uriCount = 0;
+        const insertText = ( entries
+            .map(({ uri, originalText }) => {
+            if (uri.scheme === Schemas.file) {
+                return uri.fsPath;
+            }
+            else {
+                uriCount++;
+                return originalText;
+            }
+        }))
+            .join(' ');
+        let label;
+        if (uriCount > 0) {
+            label = entries.length > 1
+                ? ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.uris',
+                "Insert Uris"
+            ))
+                : ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.uri',
+                "Insert Uri"
+            ));
+        }
+        else {
+            label = entries.length > 1
+                ? ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.paths',
+                "Insert Paths"
+            ))
+                : ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.path',
+                "Insert Path"
+            ));
+        }
+        return {
+            handledMimeType: Mimes.uriList,
+            insertText,
+            label,
+            detail: builtInLabel,
+        };
+    }
+}
+let RelativePathProvider = class RelativePathProvider extends SimplePasteAndDropProvider {
+    constructor(_workspaceContextService) {
+        super();
+        this._workspaceContextService = _workspaceContextService;
+        this.id = 'relativePath';
+        this.dropMimeTypes = [Mimes.uriList];
+        this.pasteMimeTypes = [Mimes.uriList];
+    }
+    async getEdit(dataTransfer, token) {
+        const entries = await extractUriList(dataTransfer);
+        if (!entries.length || token.isCancellationRequested) {
+            return;
+        }
+        const relativeUris = coalesce(( entries.map(({ uri }) => {
+            const root = this._workspaceContextService.getWorkspaceFolder(uri);
+            return root ? relativePath(root.uri, uri) : undefined;
+        })));
+        if (!relativeUris.length) {
+            return;
+        }
+        return {
+            handledMimeType: Mimes.uriList,
+            insertText: relativeUris.join(' '),
+            label: entries.length > 1
+                ? ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.relativePaths',
+                "Insert Relative Paths"
+            ))
+                : ( localizeWithPath(
+                'vs/editor/contrib/dropOrPasteInto/browser/defaultProviders',
+                'defaultDropProvider.uriList.relativePath',
+                "Insert Relative Path"
+            )),
+            detail: builtInLabel,
+        };
+    }
+};
+RelativePathProvider = ( __decorate([
+    ( __param(0, IWorkspaceContextService))
+], RelativePathProvider));
+async function extractUriList(dataTransfer) {
+    const urlListEntry = dataTransfer.get(Mimes.uriList);
+    if (!urlListEntry) {
+        return [];
+    }
+    const strUriList = await urlListEntry.asString();
+    const entries = [];
+    for (const entry of UriList.parse(strUriList)) {
+        try {
+            entries.push({ uri: ( URI.parse(entry)), originalText: entry });
+        }
+        catch {
+        }
+    }
+    return entries;
+}
+let DefaultDropProvidersFeature = class DefaultDropProvidersFeature extends Disposable {
+    constructor(languageFeaturesService, workspaceContextService) {
+        super();
+        this._register(languageFeaturesService.documentOnDropEditProvider.register('*', ( new DefaultTextProvider())));
+        this._register(languageFeaturesService.documentOnDropEditProvider.register('*', ( new PathProvider())));
+        this._register(languageFeaturesService.documentOnDropEditProvider.register('*', ( new RelativePathProvider(workspaceContextService))));
+    }
+};
+DefaultDropProvidersFeature = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IWorkspaceContextService))
+], DefaultDropProvidersFeature));
+let DefaultPasteProvidersFeature = class DefaultPasteProvidersFeature extends Disposable {
+    constructor(languageFeaturesService, workspaceContextService) {
+        super();
+        this._register(languageFeaturesService.documentPasteEditProvider.register('*', ( new DefaultTextProvider())));
+        this._register(languageFeaturesService.documentPasteEditProvider.register('*', ( new PathProvider())));
+        this._register(languageFeaturesService.documentPasteEditProvider.register('*', ( new RelativePathProvider(workspaceContextService))));
+    }
+};
+DefaultPasteProvidersFeature = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IWorkspaceContextService))
+], DefaultPasteProvidersFeature));
+export { DefaultDropProvidersFeature, DefaultPasteProvidersFeature };