@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/platform/userDataSync/common/settingsMerge.js

@@ -0,0 +1,299 @@
+import { parse, visit } from 'monaco-editor/esm/vs/base/common/json.js';
+import { setProperty, applyEdits, withFormatting } from '../../../base/common/jsonEdit.js';
+import { getEOL } from '../../../base/common/jsonFormatter.js';
+import { edit } from './content.js';
+function updateIgnoredSettings(targetContent, sourceContent, ignoredSettings, formattingOptions) {
+    if (ignoredSettings.length) {
+        const sourceTree = parseSettings(sourceContent);
+        const source = parse(sourceContent) || {};
+        const target = parse(targetContent);
+        if (!target) {
+            return targetContent;
+        }
+        const settingsToAdd = [];
+        for (const key of ignoredSettings) {
+            const sourceValue = source[key];
+            const targetValue = target[key];
+            if (sourceValue === undefined) {
+                targetContent = edit(targetContent, [key], undefined, formattingOptions);
+            }
+            else if (targetValue !== undefined) {
+                targetContent = edit(targetContent, [key], sourceValue, formattingOptions);
+            }
+            else {
+                settingsToAdd.push(findSettingNode(key, sourceTree));
+            }
+        }
+        settingsToAdd.sort((a, b) => a.startOffset - b.startOffset);
+        settingsToAdd.forEach(s => targetContent = addSetting(s.setting.key, sourceContent, targetContent, formattingOptions));
+    }
+    return targetContent;
+}
+function addSetting(key, sourceContent, targetContent, formattingOptions) {
+    const source = parse(sourceContent);
+    const sourceTree = parseSettings(sourceContent);
+    const targetTree = parseSettings(targetContent);
+    const insertLocation = getInsertLocation(key, sourceTree, targetTree);
+    return insertAtLocation(targetContent, key, source[key], insertLocation, targetTree, formattingOptions);
+}
+function getInsertLocation(key, sourceTree, targetTree) {
+    const sourceNodeIndex = sourceTree.findIndex(node => node.setting?.key === key);
+    const sourcePreviousNode = sourceTree[sourceNodeIndex - 1];
+    if (sourcePreviousNode) {
+        if (sourcePreviousNode.setting) {
+            const targetPreviousSetting = findSettingNode(sourcePreviousNode.setting.key, targetTree);
+            if (targetPreviousSetting) {
+                return { index: targetTree.indexOf(targetPreviousSetting), insertAfter: true };
+            }
+        }
+        else {
+            const sourcePreviousSettingNode = findPreviousSettingNode(sourceNodeIndex, sourceTree);
+            if (sourcePreviousSettingNode) {
+                const targetPreviousSetting = findSettingNode(sourcePreviousSettingNode.setting.key, targetTree);
+                if (targetPreviousSetting) {
+                    const targetNextSetting = findNextSettingNode(targetTree.indexOf(targetPreviousSetting), targetTree);
+                    const sourceCommentNodes = findNodesBetween(sourceTree, sourcePreviousSettingNode, sourceTree[sourceNodeIndex]);
+                    if (targetNextSetting) {
+                        const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetNextSetting);
+                        const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes, targetCommentNodes);
+                        if (targetCommentNode) {
+                            return { index: targetTree.indexOf(targetCommentNode), insertAfter: true };
+                        }
+                        else {
+                            return { index: targetTree.indexOf(targetNextSetting), insertAfter: false };
+                        }
+                    }
+                    else {
+                        const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetTree[targetTree.length - 1]);
+                        const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes, targetCommentNodes);
+                        if (targetCommentNode) {
+                            return { index: targetTree.indexOf(targetCommentNode), insertAfter: true };
+                        }
+                        else {
+                            return { index: targetTree.length - 1, insertAfter: true };
+                        }
+                    }
+                }
+            }
+        }
+        const sourceNextNode = sourceTree[sourceNodeIndex + 1];
+        if (sourceNextNode) {
+            if (sourceNextNode.setting) {
+                const targetNextSetting = findSettingNode(sourceNextNode.setting.key, targetTree);
+                if (targetNextSetting) {
+                    return { index: targetTree.indexOf(targetNextSetting), insertAfter: false };
+                }
+            }
+            else {
+                const sourceNextSettingNode = findNextSettingNode(sourceNodeIndex, sourceTree);
+                if (sourceNextSettingNode) {
+                    const targetNextSetting = findSettingNode(sourceNextSettingNode.setting.key, targetTree);
+                    if (targetNextSetting) {
+                        const targetPreviousSetting = findPreviousSettingNode(targetTree.indexOf(targetNextSetting), targetTree);
+                        const sourceCommentNodes = findNodesBetween(sourceTree, sourceTree[sourceNodeIndex], sourceNextSettingNode);
+                        if (targetPreviousSetting) {
+                            const targetCommentNodes = findNodesBetween(targetTree, targetPreviousSetting, targetNextSetting);
+                            const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes.reverse(), targetCommentNodes.reverse());
+                            if (targetCommentNode) {
+                                return { index: targetTree.indexOf(targetCommentNode), insertAfter: false };
+                            }
+                            else {
+                                return { index: targetTree.indexOf(targetPreviousSetting), insertAfter: true };
+                            }
+                        }
+                        else {
+                            const targetCommentNodes = findNodesBetween(targetTree, targetTree[0], targetNextSetting);
+                            const targetCommentNode = findLastMatchingTargetCommentNode(sourceCommentNodes.reverse(), targetCommentNodes.reverse());
+                            if (targetCommentNode) {
+                                return { index: targetTree.indexOf(targetCommentNode), insertAfter: false };
+                            }
+                            else {
+                                return { index: 0, insertAfter: false };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { index: targetTree.length - 1, insertAfter: true };
+}
+function insertAtLocation(content, key, value, location, tree, formattingOptions) {
+    let edits;
+    if (location.index === -1) {
+        edits = setProperty(content, [key], value, formattingOptions);
+    }
+    else {
+        edits = ( getEditToInsertAtLocation(content, key, value, location, tree, formattingOptions).map(edit => withFormatting(content, edit, formattingOptions)[0]));
+    }
+    return applyEdits(content, edits);
+}
+function getEditToInsertAtLocation(content, key, value, location, tree, formattingOptions) {
+    const newProperty = `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+    const eol = getEOL(formattingOptions, content);
+    const node = tree[location.index];
+    if (location.insertAfter) {
+        const edits = [];
+        if (node.setting) {
+            edits.push({ offset: node.endOffset, length: 0, content: ',' + newProperty });
+        }
+        else {
+            const nextSettingNode = findNextSettingNode(location.index, tree);
+            const previousSettingNode = findPreviousSettingNode(location.index, tree);
+            const previousSettingCommaOffset = previousSettingNode?.setting?.commaOffset;
+            if (previousSettingNode && previousSettingCommaOffset === undefined) {
+                edits.push({ offset: previousSettingNode.endOffset, length: 0, content: ',' });
+            }
+            const isPreviouisSettingIncludesComment = previousSettingCommaOffset !== undefined && previousSettingCommaOffset > node.endOffset;
+            edits.push({
+                offset: isPreviouisSettingIncludesComment ? previousSettingCommaOffset + 1 : node.endOffset,
+                length: 0,
+                content: nextSettingNode ? eol + newProperty + ',' : eol + newProperty
+            });
+        }
+        return edits;
+    }
+    else {
+        if (node.setting) {
+            return [{ offset: node.startOffset, length: 0, content: newProperty + ',' }];
+        }
+        const content = (tree[location.index - 1] && !tree[location.index - 1].setting  ? eol : '')
+            + newProperty
+            + (findNextSettingNode(location.index, tree) ? ',' : '')
+            + eol;
+        return [{ offset: node.startOffset, length: 0, content }];
+    }
+}
+function findSettingNode(key, tree) {
+    return tree.filter(node => node.setting?.key === key)[0];
+}
+function findPreviousSettingNode(index, tree) {
+    for (let i = index - 1; i >= 0; i--) {
+        if (tree[i].setting) {
+            return tree[i];
+        }
+    }
+    return undefined;
+}
+function findNextSettingNode(index, tree) {
+    for (let i = index + 1; i < tree.length; i++) {
+        if (tree[i].setting) {
+            return tree[i];
+        }
+    }
+    return undefined;
+}
+function findNodesBetween(nodes, from, till) {
+    const fromIndex = nodes.indexOf(from);
+    const tillIndex = nodes.indexOf(till);
+    return nodes.filter((node, index) => fromIndex < index && index < tillIndex);
+}
+function findLastMatchingTargetCommentNode(sourceComments, targetComments) {
+    if (sourceComments.length && targetComments.length) {
+        let index = 0;
+        for (; index < targetComments.length && index < sourceComments.length; index++) {
+            if (sourceComments[index].value !== targetComments[index].value) {
+                return targetComments[index - 1];
+            }
+        }
+        return targetComments[index - 1];
+    }
+    return undefined;
+}
+function parseSettings(content) {
+    const nodes = [];
+    let hierarchyLevel = -1;
+    let startOffset;
+    let key;
+    const visitor = {
+        onObjectBegin: (offset) => {
+            hierarchyLevel++;
+        },
+        onObjectProperty: (name, offset, length) => {
+            if (hierarchyLevel === 0) {
+                startOffset = offset;
+                key = name;
+            }
+        },
+        onObjectEnd: (offset, length) => {
+            hierarchyLevel--;
+            if (hierarchyLevel === 0) {
+                nodes.push({
+                    startOffset,
+                    endOffset: offset + length,
+                    value: content.substring(startOffset, offset + length),
+                    setting: {
+                        key,
+                        commaOffset: undefined
+                    }
+                });
+            }
+        },
+        onArrayBegin: (offset, length) => {
+            hierarchyLevel++;
+        },
+        onArrayEnd: (offset, length) => {
+            hierarchyLevel--;
+            if (hierarchyLevel === 0) {
+                nodes.push({
+                    startOffset,
+                    endOffset: offset + length,
+                    value: content.substring(startOffset, offset + length),
+                    setting: {
+                        key,
+                        commaOffset: undefined
+                    }
+                });
+            }
+        },
+        onLiteralValue: (value, offset, length) => {
+            if (hierarchyLevel === 0) {
+                nodes.push({
+                    startOffset,
+                    endOffset: offset + length,
+                    value: content.substring(startOffset, offset + length),
+                    setting: {
+                        key,
+                        commaOffset: undefined
+                    }
+                });
+            }
+        },
+        onSeparator: (sep, offset, length) => {
+            if (hierarchyLevel === 0) {
+                if (sep === ',') {
+                    let index = nodes.length - 1;
+                    for (; index >= 0; index--) {
+                        if (nodes[index].setting) {
+                            break;
+                        }
+                    }
+                    const node = nodes[index];
+                    if (node) {
+                        nodes.splice(index, 1, {
+                            startOffset: node.startOffset,
+                            endOffset: node.endOffset,
+                            value: node.value,
+                            setting: {
+                                key: node.setting.key,
+                                commaOffset: offset
+                            }
+                        });
+                    }
+                }
+            }
+        },
+        onComment: (offset, length) => {
+            if (hierarchyLevel === 0) {
+                nodes.push({
+                    startOffset: offset,
+                    endOffset: offset + length,
+                    value: content.substring(offset, offset + length),
+                });
+            }
+        }
+    };
+    visit(content, visitor);
+    return nodes;
+}
+export { addSetting, updateIgnoredSettings };

package/dist/vscode/vs/platform/workspace/common/editSessions.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IEditSessionIdentityService = ( createDecorator('editSessionIdentityService'));
+export { IEditSessionIdentityService };

package/dist/vscode/vs/platform/workspace/common/virtualWorkspace.js

@@ -0,0 +1,17 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+function isVirtualResource(resource) {
+    return resource.scheme !== Schemas.file && resource.scheme !== Schemas.vscodeRemote;
+}
+function getVirtualWorkspaceLocation(workspace) {
+    if (workspace.folders.length) {
+        return workspace.folders.every(f => isVirtualResource(f.uri)) ? workspace.folders[0].uri : undefined;
+    }
+    else if (workspace.configuration && isVirtualResource(workspace.configuration)) {
+        return workspace.configuration;
+    }
+    return undefined;
+}
+function getVirtualWorkspaceScheme(workspace) {
+    return getVirtualWorkspaceLocation(workspace)?.scheme;
+}
+export { getVirtualWorkspaceLocation, getVirtualWorkspaceScheme, isVirtualResource };

package/dist/vscode/vs/platform/workspaces/common/workspaces.js

@@ -0,0 +1,195 @@
+import { isUNC, toSlashes } from 'monaco-editor/esm/vs/base/common/extpath.js';
+import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import { setProperty, applyEdits, removeProperty } from '../../../base/common/jsonEdit.js';
+import { normalizeDriveLetter } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { posix, isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { isWindows, isLinux, isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isEqualAuthority } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { getRemoteAuthority } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { WorkspaceFolder } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+const IWorkspacesService = ( (createDecorator('workspacesService')));
+function isRecentWorkspace(curr) {
+    return curr.hasOwnProperty('workspace');
+}
+function isRecentFolder(curr) {
+    return curr.hasOwnProperty('folderUri');
+}
+function isRecentFile(curr) {
+    return curr.hasOwnProperty('fileUri');
+}
+function isStoredWorkspaceFolder(obj) {
+    return isRawFileWorkspaceFolder(obj) || isRawUriWorkspaceFolder(obj);
+}
+function isRawFileWorkspaceFolder(obj) {
+    const candidate = obj;
+    return typeof candidate?.path === 'string' && (!candidate.name || typeof candidate.name === 'string');
+}
+function isRawUriWorkspaceFolder(obj) {
+    const candidate = obj;
+    return typeof candidate?.uri === 'string' && (!candidate.name || typeof candidate.name === 'string');
+}
+function getStoredWorkspaceFolder(folderURI, forceAbsolute, folderName, targetConfigFolderURI, extUri) {
+    if (folderURI.scheme !== targetConfigFolderURI.scheme) {
+        return { name: folderName, uri: ( (folderURI.toString(true))) };
+    }
+    let folderPath = !forceAbsolute ? extUri.relativePath(targetConfigFolderURI, folderURI) : undefined;
+    if (folderPath !== undefined) {
+        if (folderPath.length === 0) {
+            folderPath = '.';
+        }
+        else {
+            if (isWindows) {
+                folderPath = massagePathForWindows(folderPath);
+            }
+        }
+    }
+    else {
+        if (folderURI.scheme === Schemas.file) {
+            folderPath = folderURI.fsPath;
+            if (isWindows) {
+                folderPath = massagePathForWindows(folderPath);
+            }
+        }
+        else if (!extUri.isEqualAuthority(folderURI.authority, targetConfigFolderURI.authority)) {
+            return { name: folderName, uri: ( (folderURI.toString(true))) };
+        }
+        else {
+            folderPath = folderURI.path;
+        }
+    }
+    return { name: folderName, path: folderPath };
+}
+function massagePathForWindows(folderPath) {
+    folderPath = normalizeDriveLetter(folderPath);
+    if (!isUNC(folderPath)) {
+        folderPath = toSlashes(folderPath);
+    }
+    return folderPath;
+}
+function toWorkspaceFolders(configuredFolders, workspaceConfigFile, extUri) {
+    const result = [];
+    const seen = ( (new Set()));
+    const relativeTo = extUri.dirname(workspaceConfigFile);
+    for (const configuredFolder of configuredFolders) {
+        let uri = undefined;
+        if (isRawFileWorkspaceFolder(configuredFolder)) {
+            if (configuredFolder.path) {
+                uri = extUri.resolvePath(relativeTo, configuredFolder.path);
+            }
+        }
+        else if (isRawUriWorkspaceFolder(configuredFolder)) {
+            try {
+                uri = ( (URI.parse(configuredFolder.uri)));
+                if (uri.path[0] !== posix.sep) {
+                    uri = uri.with({ path: posix.sep + uri.path });
+                }
+            }
+            catch (e) {
+                console.warn(e);
+            }
+        }
+        if (uri) {
+            const comparisonKey = extUri.getComparisonKey(uri);
+            if (!seen.has(comparisonKey)) {
+                seen.add(comparisonKey);
+                const name = configuredFolder.name || extUri.basenameOrAuthority(uri);
+                result.push(( (new WorkspaceFolder({ uri, name, index: result.length }, configuredFolder))));
+            }
+        }
+    }
+    return result;
+}
+function rewriteWorkspaceFileForNewLocation(rawWorkspaceContents, configPathURI, isFromUntitledWorkspace, targetConfigPathURI, extUri) {
+    const storedWorkspace = doParseStoredWorkspace(configPathURI, rawWorkspaceContents);
+    const sourceConfigFolder = extUri.dirname(configPathURI);
+    const targetConfigFolder = extUri.dirname(targetConfigPathURI);
+    const rewrittenFolders = [];
+    for (const folder of storedWorkspace.folders) {
+        const folderURI = isRawFileWorkspaceFolder(folder) ? extUri.resolvePath(sourceConfigFolder, folder.path) : ( (URI.parse(folder.uri)));
+        let absolute;
+        if (isFromUntitledWorkspace) {
+            absolute = false;
+        }
+        else {
+            absolute = !isRawFileWorkspaceFolder(folder) || isAbsolute(folder.path);
+        }
+        rewrittenFolders.push(getStoredWorkspaceFolder(folderURI, absolute, folder.name, targetConfigFolder, extUri));
+    }
+    const formattingOptions = { insertSpaces: false, tabSize: 4, eol: (isLinux || isMacintosh) ? '\n' : '\r\n' };
+    const edits = setProperty(rawWorkspaceContents, ['folders'], rewrittenFolders, formattingOptions);
+    let newContent = applyEdits(rawWorkspaceContents, edits);
+    if (isEqualAuthority(storedWorkspace.remoteAuthority, getRemoteAuthority(targetConfigPathURI))) {
+        newContent = applyEdits(newContent, removeProperty(newContent, ['remoteAuthority'], formattingOptions));
+    }
+    return newContent;
+}
+function doParseStoredWorkspace(path, contents) {
+    const storedWorkspace = Json.parse(contents);
+    if (storedWorkspace && Array.isArray(storedWorkspace.folders)) {
+        storedWorkspace.folders = storedWorkspace.folders.filter(folder => isStoredWorkspaceFolder(folder));
+    }
+    else {
+        throw new Error(`${path} looks like an invalid workspace file.`);
+    }
+    return storedWorkspace;
+}
+function isSerializedRecentWorkspace(data) {
+    return data.workspace && typeof data.workspace === 'object' && typeof data.workspace.id === 'string' && typeof data.workspace.configPath === 'string';
+}
+function isSerializedRecentFolder(data) {
+    return typeof data.folderUri === 'string';
+}
+function isSerializedRecentFile(data) {
+    return typeof data.fileUri === 'string';
+}
+function restoreRecentlyOpened(data, logService) {
+    const result = { workspaces: [], files: [] };
+    if (data) {
+        const restoreGracefully = function (entries, onEntry) {
+            for (let i = 0; i < entries.length; i++) {
+                try {
+                    onEntry(entries[i], i);
+                }
+                catch (e) {
+                    logService.warn(`Error restoring recent entry ${JSON.stringify(entries[i])}: ${( ( e.toString()))}. Skip entry.`);
+                }
+            }
+        };
+        const storedRecents = data;
+        if (Array.isArray(storedRecents.entries)) {
+            restoreGracefully(storedRecents.entries, entry => {
+                const label = entry.label;
+                const remoteAuthority = entry.remoteAuthority;
+                if (isSerializedRecentWorkspace(entry)) {
+                    result.workspaces.push({ label, remoteAuthority, workspace: { id: entry.workspace.id, configPath: ( (URI.parse(entry.workspace.configPath))) } });
+                }
+                else if (isSerializedRecentFolder(entry)) {
+                    result.workspaces.push({ label, remoteAuthority, folderUri: ( (URI.parse(entry.folderUri))) });
+                }
+                else if (isSerializedRecentFile(entry)) {
+                    result.files.push({ label, remoteAuthority, fileUri: ( (URI.parse(entry.fileUri))) });
+                }
+            });
+        }
+    }
+    return result;
+}
+function toStoreData(recents) {
+    const serialized = { entries: [] };
+    for (const recent of recents.workspaces) {
+        if (isRecentFolder(recent)) {
+            serialized.entries.push({ folderUri: ( (recent.folderUri.toString())), label: recent.label, remoteAuthority: recent.remoteAuthority });
+        }
+        else {
+            serialized.entries.push({ workspace: { id: recent.workspace.id, configPath: ( (recent.workspace.configPath.toString())) }, label: recent.label, remoteAuthority: recent.remoteAuthority });
+        }
+    }
+    for (const recent of recents.files) {
+        serialized.entries.push({ fileUri: ( (recent.fileUri.toString())), label: recent.label, remoteAuthority: recent.remoteAuthority });
+    }
+    return serialized;
+}
+export { IWorkspacesService, getStoredWorkspaceFolder, isRecentFile, isRecentFolder, isRecentWorkspace, isStoredWorkspaceFolder, restoreRecentlyOpened, rewriteWorkspaceFileForNewLocation, toStoreData, toWorkspaceFolders };

package/dist/vscode/vs/workbench/api/browser/mainThreadBulkEdits.js

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { IBulkEditService, ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { ResourceNotebookCellEdit } from '../../contrib/bulkEdit/browser/bulkCellEdits.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+let MainThreadBulkEdits = class MainThreadBulkEdits {
+    constructor(_extHostContext, _bulkEditService, _logService, _uriIdentService) {
+        this._bulkEditService = _bulkEditService;
+        this._logService = _logService;
+        this._uriIdentService = _uriIdentService;
+    }
+    dispose() { }
+    $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
+        const edits = reviveWorkspaceEditDto(dto, this._uriIdentService);
+        return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
+            this._logService.warn(`IGNORING workspace edit: ${err}`);
+            return false;
+        });
+    }
+};
+MainThreadBulkEdits = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadBulkEdits),
+    ( __param(1, IBulkEditService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IUriIdentityService))
+], MainThreadBulkEdits);
+function reviveWorkspaceEditDto(data, uriIdentityService) {
+    if (!data || !data.edits) {
+        return data;
+    }
+    const result = revive(data);
+    for (const edit of result.edits) {
+        if (ResourceTextEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+        if (ResourceFileEdit.is(edit)) {
+            edit.newResource = edit.newResource && uriIdentityService.asCanonicalUri(edit.newResource);
+            edit.oldResource = edit.oldResource && uriIdentityService.asCanonicalUri(edit.oldResource);
+        }
+        if (ResourceNotebookCellEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+    }
+    return data;
+}
+export { MainThreadBulkEdits, reviveWorkspaceEditDto };

package/dist/vscode/vs/workbench/api/browser/mainThreadClipboard.js

@@ -0,0 +1,22 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+let MainThreadClipboard = class MainThreadClipboard {
+    constructor(_context, _clipboardService) {
+        this._clipboardService = _clipboardService;
+    }
+    dispose() {
+    }
+    $readText() {
+        return this._clipboardService.readText();
+    }
+    $writeText(value) {
+        return this._clipboardService.writeText(value);
+    }
+};
+MainThreadClipboard = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadClipboard),
+    ( __param(1, IClipboardService))
+], MainThreadClipboard);
+export { MainThreadClipboard };