@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/common/extHostWorkspace.js

@@ -0,0 +1,534 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { mapArrayOrNot, delta as delta$1 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter, AsyncEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Counter } from 'monaco-editor/esm/vs/base/common/numbers.js';
+import { basename, dirname, basenameOrAuthority, relativePath, ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { withUndefinedAsNull } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Workspace as Workspace$1, WorkspaceFolder } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IExtHostFileSystemInfo } from './extHostFileSystemInfo.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { GlobPattern } from './extHostTypeConverters.js';
+import { Range } from './extHostTypes.js';
+import { IURITransformerService } from './extHostUriTransformerService.js';
+import { resultIsMatch } from '../../services/search/common/search.js';
+import { MainContext } from './extHost.protocol.js';
+function isFolderEqual(folderA, folderB, extHostFileSystemInfo) {
+    return ( new ExtUri(uri => ignorePathCasing(uri, extHostFileSystemInfo))).isEqual(folderA, folderB);
+}
+function compareWorkspaceFolderByUri(a, b, extHostFileSystemInfo) {
+    return isFolderEqual(a.uri, b.uri, extHostFileSystemInfo) ? 0 : compare(( a.uri.toString()), ( b.uri.toString()));
+}
+function compareWorkspaceFolderByUriAndNameAndIndex(a, b, extHostFileSystemInfo) {
+    if (a.index !== b.index) {
+        return a.index < b.index ? -1 : 1;
+    }
+    return isFolderEqual(a.uri, b.uri, extHostFileSystemInfo) ? compare(a.name, b.name) : compare(( a.uri.toString()), ( b.uri.toString()));
+}
+function delta(oldFolders, newFolders, compare, extHostFileSystemInfo) {
+    const oldSortedFolders = oldFolders.slice(0).sort((a, b) => compare(a, b, extHostFileSystemInfo));
+    const newSortedFolders = newFolders.slice(0).sort((a, b) => compare(a, b, extHostFileSystemInfo));
+    return delta$1(oldSortedFolders, newSortedFolders, (a, b) => compare(a, b, extHostFileSystemInfo));
+}
+function ignorePathCasing(uri, extHostFileSystemInfo) {
+    const capabilities = extHostFileSystemInfo.getCapabilities(uri.scheme);
+    return !(capabilities && ((capabilities & 1024) ));
+}
+class ExtHostWorkspaceImpl extends Workspace$1 {
+    static toExtHostWorkspace(data, previousConfirmedWorkspace, previousUnconfirmedWorkspace, extHostFileSystemInfo) {
+        if (!data) {
+            return { workspace: null, added: [], removed: [] };
+        }
+        const { id, name, folders, configuration, transient, isUntitled } = data;
+        const newWorkspaceFolders = [];
+        const oldWorkspace = previousConfirmedWorkspace;
+        if (previousConfirmedWorkspace) {
+            folders.forEach((folderData, index) => {
+                const folderUri = URI.revive(folderData.uri);
+                const existingFolder = ExtHostWorkspaceImpl._findFolder(previousUnconfirmedWorkspace || previousConfirmedWorkspace, folderUri, extHostFileSystemInfo);
+                if (existingFolder) {
+                    existingFolder.name = folderData.name;
+                    existingFolder.index = folderData.index;
+                    newWorkspaceFolders.push(existingFolder);
+                }
+                else {
+                    newWorkspaceFolders.push({ uri: folderUri, name: folderData.name, index });
+                }
+            });
+        }
+        else {
+            newWorkspaceFolders.push(...( folders.map(({ uri, name, index }) => ({ uri: URI.revive(uri), name, index }))));
+        }
+        newWorkspaceFolders.sort((f1, f2) => f1.index < f2.index ? -1 : 1);
+        const workspace = ( new ExtHostWorkspaceImpl(
+            id,
+            name,
+            newWorkspaceFolders,
+            !!transient,
+            configuration ? URI.revive(configuration) : null,
+            !!isUntitled,
+            uri => ignorePathCasing(uri, extHostFileSystemInfo)
+        ));
+        const { added, removed } = delta(oldWorkspace ? oldWorkspace.workspaceFolders : [], workspace.workspaceFolders, compareWorkspaceFolderByUri, extHostFileSystemInfo);
+        return { workspace, added, removed };
+    }
+    static _findFolder(workspace, folderUriToFind, extHostFileSystemInfo) {
+        for (let i = 0; i < workspace.folders.length; i++) {
+            const folder = workspace.workspaceFolders[i];
+            if (isFolderEqual(folder.uri, folderUriToFind, extHostFileSystemInfo)) {
+                return folder;
+            }
+        }
+        return undefined;
+    }
+    constructor(id, _name, folders, transient, configuration, _isUntitled, ignorePathCasing) {
+        super(id, ( folders.map(f => ( new WorkspaceFolder(f)))), transient, configuration, ignorePathCasing);
+        this._name = _name;
+        this._isUntitled = _isUntitled;
+        this._workspaceFolders = [];
+        this._structure = TernarySearchTree.forUris(ignorePathCasing);
+        folders.forEach(folder => {
+            this._workspaceFolders.push(folder);
+            this._structure.set(folder.uri, folder);
+        });
+    }
+    get name() {
+        return this._name;
+    }
+    get isUntitled() {
+        return this._isUntitled;
+    }
+    get workspaceFolders() {
+        return this._workspaceFolders.slice(0);
+    }
+    getWorkspaceFolder(uri, resolveParent) {
+        if (resolveParent && this._structure.get(uri)) {
+            uri = dirname(uri);
+        }
+        return this._structure.findSubstr(uri);
+    }
+    resolveWorkspaceFolder(uri) {
+        return this._structure.get(uri);
+    }
+}
+let ExtHostWorkspace = class ExtHostWorkspace {
+    constructor(extHostRpc, initData, extHostFileSystemInfo, logService, uriTransformerService) {
+        this._onDidChangeWorkspace = ( new Emitter());
+        this.onDidChangeWorkspace = this._onDidChangeWorkspace.event;
+        this._onDidGrantWorkspaceTrust = ( new Emitter());
+        this.onDidGrantWorkspaceTrust = this._onDidGrantWorkspaceTrust.event;
+        this._activeSearchCallbacks = [];
+        this._trusted = false;
+        this._editSessionIdentityProviders = ( new Map());
+        this._providerHandlePool = 0;
+        this._onWillCreateEditSessionIdentityEvent = ( new AsyncEmitter());
+        this._logService = logService;
+        this._extHostFileSystemInfo = extHostFileSystemInfo;
+        this._uriTransformerService = uriTransformerService;
+        this._requestIdProvider = ( new Counter());
+        this._barrier = ( new Barrier());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadWorkspace));
+        this._messageService = ( extHostRpc.getProxy(MainContext.MainThreadMessageService));
+        const data = initData.workspace;
+        this._confirmedWorkspace = data ? ( new ExtHostWorkspaceImpl(
+            data.id,
+            data.name,
+            [],
+            !!data.transient,
+            data.configuration ? URI.revive(data.configuration) : null,
+            !!data.isUntitled,
+            uri => ignorePathCasing(uri, extHostFileSystemInfo)
+        )) : undefined;
+    }
+    $initializeWorkspace(data, trusted) {
+        this._trusted = trusted;
+        this.$acceptWorkspaceData(data);
+        this._barrier.open();
+    }
+    waitForInitializeCall() {
+        return this._barrier.wait();
+    }
+    get workspace() {
+        return this._actualWorkspace;
+    }
+    get name() {
+        return this._actualWorkspace ? this._actualWorkspace.name : undefined;
+    }
+    get workspaceFile() {
+        if (this._actualWorkspace) {
+            if (this._actualWorkspace.configuration) {
+                if (this._actualWorkspace.isUntitled) {
+                    return ( URI.from(
+                        { scheme: Schemas.untitled, path: basename(dirname(this._actualWorkspace.configuration)) }
+                    ));
+                }
+                return this._actualWorkspace.configuration;
+            }
+        }
+        return undefined;
+    }
+    get _actualWorkspace() {
+        return this._unconfirmedWorkspace || this._confirmedWorkspace;
+    }
+    getWorkspaceFolders() {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.workspaceFolders.slice(0);
+    }
+    async getWorkspaceFolders2() {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.workspaceFolders.slice(0);
+    }
+    updateWorkspaceFolders(extension, index, deleteCount, ...workspaceFoldersToAdd) {
+        const validatedDistinctWorkspaceFoldersToAdd = [];
+        if (Array.isArray(workspaceFoldersToAdd)) {
+            workspaceFoldersToAdd.forEach(folderToAdd => {
+                if (URI.isUri(folderToAdd.uri) && !( validatedDistinctWorkspaceFoldersToAdd.some(f => isFolderEqual(f.uri, folderToAdd.uri, this._extHostFileSystemInfo)))) {
+                    validatedDistinctWorkspaceFoldersToAdd.push({ uri: folderToAdd.uri, name: folderToAdd.name || basenameOrAuthority(folderToAdd.uri) });
+                }
+            });
+        }
+        if (!!this._unconfirmedWorkspace) {
+            return false;
+        }
+        if (( [index, deleteCount].some(i => typeof i !== 'number' || i < 0))) {
+            return false;
+        }
+        if (deleteCount === 0 && validatedDistinctWorkspaceFoldersToAdd.length === 0) {
+            return false;
+        }
+        const currentWorkspaceFolders = this._actualWorkspace ? this._actualWorkspace.workspaceFolders : [];
+        if (index + deleteCount > currentWorkspaceFolders.length) {
+            return false;
+        }
+        const newWorkspaceFolders = currentWorkspaceFolders.slice(0);
+        newWorkspaceFolders.splice(index, deleteCount, ...( validatedDistinctWorkspaceFoldersToAdd.map(
+            f => ({ uri: f.uri, name: f.name || basenameOrAuthority(f.uri), index: undefined  })
+        )));
+        for (let i = 0; i < newWorkspaceFolders.length; i++) {
+            const folder = newWorkspaceFolders[i];
+            if (( newWorkspaceFolders.some(
+                (otherFolder, index) => index !== i && isFolderEqual(folder.uri, otherFolder.uri, this._extHostFileSystemInfo)
+            ))) {
+                return false;
+            }
+        }
+        newWorkspaceFolders.forEach((f, index) => f.index = index);
+        const { added, removed } = delta(currentWorkspaceFolders, newWorkspaceFolders, compareWorkspaceFolderByUriAndNameAndIndex, this._extHostFileSystemInfo);
+        if (added.length === 0 && removed.length === 0) {
+            return false;
+        }
+        if (this._proxy) {
+            const extName = extension.displayName || extension.name;
+            this._proxy.$updateWorkspaceFolders(extName, index, deleteCount, validatedDistinctWorkspaceFoldersToAdd).then(undefined, error => {
+                this._unconfirmedWorkspace = undefined;
+                const options = { source: { identifier: extension.identifier, label: extension.displayName || extension.name } };
+                this._messageService.$showMessage(Severity.Error, ( localize(
+                    'updateerror',
+                    "Extension '{0}' failed to update workspace folders: {1}",
+                    extName,
+                    ( error.toString())
+                )), options, []);
+            });
+        }
+        this.trySetWorkspaceFolders(newWorkspaceFolders);
+        return true;
+    }
+    getWorkspaceFolder(uri, resolveParent) {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.getWorkspaceFolder(uri, resolveParent);
+    }
+    async getWorkspaceFolder2(uri, resolveParent) {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.getWorkspaceFolder(uri, resolveParent);
+    }
+    async resolveWorkspaceFolder(uri) {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.resolveWorkspaceFolder(uri);
+    }
+    getPath() {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        const { folders } = this._actualWorkspace;
+        if (folders.length === 0) {
+            return undefined;
+        }
+        return folders[0].uri.fsPath;
+    }
+    getRelativePath(pathOrUri, includeWorkspace) {
+        let resource;
+        let path = '';
+        if (typeof pathOrUri === 'string') {
+            resource = URI.file(pathOrUri);
+            path = pathOrUri;
+        }
+        else if (typeof pathOrUri !== 'undefined') {
+            resource = pathOrUri;
+            path = pathOrUri.fsPath;
+        }
+        if (!resource) {
+            return path;
+        }
+        const folder = this.getWorkspaceFolder(resource, true);
+        if (!folder) {
+            return path;
+        }
+        if (typeof includeWorkspace === 'undefined' && this._actualWorkspace) {
+            includeWorkspace = this._actualWorkspace.folders.length > 1;
+        }
+        let result = relativePath(folder.uri, resource);
+        if (includeWorkspace && folder.name) {
+            result = `${folder.name}/${result}`;
+        }
+        return result;
+    }
+    trySetWorkspaceFolders(folders) {
+        if (this._actualWorkspace) {
+            this._unconfirmedWorkspace = ExtHostWorkspaceImpl.toExtHostWorkspace({
+                id: this._actualWorkspace.id,
+                name: this._actualWorkspace.name,
+                configuration: this._actualWorkspace.configuration,
+                folders,
+                isUntitled: this._actualWorkspace.isUntitled
+            }, this._actualWorkspace, undefined, this._extHostFileSystemInfo).workspace || undefined;
+        }
+    }
+    $acceptWorkspaceData(data) {
+        const { workspace, added, removed } = ExtHostWorkspaceImpl.toExtHostWorkspace(data, this._confirmedWorkspace, this._unconfirmedWorkspace, this._extHostFileSystemInfo);
+        this._confirmedWorkspace = workspace || undefined;
+        this._unconfirmedWorkspace = undefined;
+        this._onDidChangeWorkspace.fire(( Object.freeze({
+            added,
+            removed,
+        })));
+    }
+    findFiles(include, exclude, maxResults, extensionId, token = CancellationToken.None) {
+        this._logService.trace(`extHostWorkspace#findFiles: fileSearch, extension: ${extensionId.value}, entryPoint: findFiles`);
+        let excludePatternOrDisregardExcludes = undefined;
+        if (exclude === null) {
+            excludePatternOrDisregardExcludes = false;
+        }
+        else if (exclude) {
+            if (typeof exclude === 'string') {
+                excludePatternOrDisregardExcludes = exclude;
+            }
+            else {
+                excludePatternOrDisregardExcludes = exclude.pattern;
+            }
+        }
+        if (token && token.isCancellationRequested) {
+            return Promise.resolve([]);
+        }
+        const { includePattern, folder } = parseSearchInclude(GlobPattern.from(include));
+        return this._proxy.$startFileSearch(withUndefinedAsNull(includePattern), withUndefinedAsNull(folder), withUndefinedAsNull(excludePatternOrDisregardExcludes), withUndefinedAsNull(maxResults), token)
+            .then(data => Array.isArray(data) ? ( data.map(d => URI.revive(d))) : []);
+    }
+    async findTextInFiles(query, options, callback, extensionId, token = CancellationToken.None) {
+        this._logService.trace(`extHostWorkspace#findTextInFiles: textSearch, extension: ${extensionId.value}, entryPoint: findTextInFiles`);
+        const requestId = this._requestIdProvider.getNext();
+        const previewOptions = typeof options.previewOptions === 'undefined' ?
+            {
+                matchLines: 100,
+                charsPerLine: 10000
+            } :
+            options.previewOptions;
+        const { includePattern, folder } = parseSearchInclude(GlobPattern.from(options.include));
+        const excludePattern = (typeof options.exclude === 'string') ? options.exclude :
+            options.exclude ? options.exclude.pattern : undefined;
+        const queryOptions = {
+            ignoreSymlinks: typeof options.followSymlinks === 'boolean' ? !options.followSymlinks : undefined,
+            disregardIgnoreFiles: typeof options.useIgnoreFiles === 'boolean' ? !options.useIgnoreFiles : undefined,
+            disregardGlobalIgnoreFiles: typeof options.useGlobalIgnoreFiles === 'boolean' ? !options.useGlobalIgnoreFiles : undefined,
+            disregardParentIgnoreFiles: typeof options.useParentIgnoreFiles === 'boolean' ? !options.useParentIgnoreFiles : undefined,
+            disregardExcludeSettings: typeof options.useDefaultExcludes === 'boolean' ? !options.useDefaultExcludes : true,
+            fileEncoding: options.encoding,
+            maxResults: options.maxResults,
+            previewOptions,
+            afterContext: options.afterContext,
+            beforeContext: options.beforeContext,
+            includePattern: includePattern,
+            excludePattern: excludePattern
+        };
+        this._activeSearchCallbacks[requestId] = p => {
+            const uri = URI.revive(p.resource);
+            p.results.forEach(result => {
+                if (resultIsMatch(result)) {
+                    callback({
+                        uri,
+                        preview: {
+                            text: result.preview.text,
+                            matches: mapArrayOrNot(result.preview.matches, m => ( new Range(m.startLineNumber, m.startColumn, m.endLineNumber, m.endColumn)))
+                        },
+                        ranges: mapArrayOrNot(result.ranges, r => ( new Range(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn)))
+                    });
+                }
+                else {
+                    callback({
+                        uri,
+                        text: result.text,
+                        lineNumber: result.lineNumber
+                    });
+                }
+            });
+        };
+        if (token.isCancellationRequested) {
+            return {};
+        }
+        try {
+            const result = await this._proxy.$startTextSearch(query, withUndefinedAsNull(folder), queryOptions, requestId, token);
+            delete this._activeSearchCallbacks[requestId];
+            return result || {};
+        }
+        catch (err) {
+            delete this._activeSearchCallbacks[requestId];
+            throw err;
+        }
+    }
+    $handleTextSearchResult(result, requestId) {
+        this._activeSearchCallbacks[requestId]?.(result);
+    }
+    saveAll(includeUntitled) {
+        return this._proxy.$saveAll(includeUntitled);
+    }
+    resolveProxy(url) {
+        return this._proxy.$resolveProxy(url);
+    }
+    get trusted() {
+        return this._trusted;
+    }
+    requestWorkspaceTrust(options) {
+        return this._proxy.$requestWorkspaceTrust(options);
+    }
+    $onDidGrantWorkspaceTrust() {
+        if (!this._trusted) {
+            this._trusted = true;
+            this._onDidGrantWorkspaceTrust.fire();
+        }
+    }
+    registerEditSessionIdentityProvider(scheme, provider) {
+        if (this._editSessionIdentityProviders.has(scheme)) {
+            throw new Error(`A provider has already been registered for scheme ${scheme}`);
+        }
+        this._editSessionIdentityProviders.set(scheme, provider);
+        const outgoingScheme = this._uriTransformerService.transformOutgoingScheme(scheme);
+        const handle = this._providerHandlePool++;
+        this._proxy.$registerEditSessionIdentityProvider(handle, outgoingScheme);
+        return toDisposable(() => {
+            this._editSessionIdentityProviders.delete(scheme);
+            this._proxy.$unregisterEditSessionIdentityProvider(handle);
+        });
+    }
+    async $getEditSessionIdentifier(workspaceFolder, cancellationToken) {
+        this._logService.info('Getting edit session identifier for workspaceFolder', workspaceFolder);
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (!folder) {
+            this._logService.warn('Unable to resolve workspace folder');
+            return undefined;
+        }
+        this._logService.info('Invoking #provideEditSessionIdentity for workspaceFolder', folder);
+        const provider = this._editSessionIdentityProviders.get(folder.uri.scheme);
+        this._logService.info(`Provider for scheme ${folder.uri.scheme} is defined: `, !!provider);
+        if (!provider) {
+            return undefined;
+        }
+        const result = await provider.provideEditSessionIdentity(folder, cancellationToken);
+        this._logService.info('Provider returned edit session identifier: ', result);
+        if (!result) {
+            return undefined;
+        }
+        return result;
+    }
+    async $provideEditSessionIdentityMatch(workspaceFolder, identity1, identity2, cancellationToken) {
+        this._logService.info('Getting edit session identifier for workspaceFolder', workspaceFolder);
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (!folder) {
+            this._logService.warn('Unable to resolve workspace folder');
+            return undefined;
+        }
+        this._logService.info('Invoking #provideEditSessionIdentity for workspaceFolder', folder);
+        const provider = this._editSessionIdentityProviders.get(folder.uri.scheme);
+        this._logService.info(`Provider for scheme ${folder.uri.scheme} is defined: `, !!provider);
+        if (!provider) {
+            return undefined;
+        }
+        const result = await provider.provideEditSessionIdentityMatch?.(identity1, identity2, cancellationToken);
+        this._logService.info('Provider returned edit session identifier match result: ', result);
+        if (!result) {
+            return undefined;
+        }
+        return result;
+    }
+    getOnWillCreateEditSessionIdentityEvent(extension) {
+        return (listener, thisArg, disposables) => {
+            const wrappedListener = function wrapped(e) { listener.call(thisArg, e); };
+            wrappedListener.extension = extension;
+            return this._onWillCreateEditSessionIdentityEvent.event(wrappedListener, undefined, disposables);
+        };
+    }
+    async $onWillCreateEditSessionIdentity(workspaceFolder, token, timeout) {
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (folder === undefined) {
+            throw new Error('Unable to resolve workspace folder');
+        }
+        await this._onWillCreateEditSessionIdentityEvent.fireAsync({ workspaceFolder: folder }, token, async (thenable, listener) => {
+            const now = Date.now();
+            await Promise.resolve(thenable);
+            if (Date.now() - now > timeout) {
+                this._logService.warn('SLOW edit session create-participant', listener.extension.identifier);
+            }
+        });
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+    }
+};
+ExtHostWorkspace = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService)),
+    ( __param(2, IExtHostFileSystemInfo)),
+    ( __param(3, ILogService)),
+    ( __param(4, IURITransformerService))
+], ExtHostWorkspace));
+const IExtHostWorkspace = ( createDecorator('IExtHostWorkspace'));
+function parseSearchInclude(include) {
+    let includePattern;
+    let includeFolder;
+    if (include) {
+        if (typeof include === 'string') {
+            includePattern = include;
+        }
+        else {
+            includePattern = include.pattern;
+            includeFolder = URI.revive(include.baseUri);
+        }
+    }
+    return {
+        includePattern,
+        folder: includeFolder
+    };
+}
+export { ExtHostWorkspace, IExtHostWorkspace };

package/dist/vscode/vs/workbench/api/common/jsonValidationExtensionPoint.js

@@ -0,0 +1,97 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionsRegistry } from '../../services/extensions/common/extensionsRegistry.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+const configurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'jsonValidation',
+    defaultExtensionKind: ['workspace', 'web'],
+    jsonSchema: {
+        description: ( nls.localize('contributes.jsonValidation', 'Contributes json schema configuration.')),
+        type: 'array',
+        defaultSnippets: [{ body: [{ fileMatch: '${1:file.json}', url: '${2:url}' }] }],
+        items: {
+            type: 'object',
+            defaultSnippets: [{ body: { fileMatch: '${1:file.json}', url: '${2:url}' } }],
+            properties: {
+                fileMatch: {
+                    type: ['string', 'array'],
+                    description: ( nls.localize(
+                        'contributes.jsonValidation.fileMatch',
+                        'The file pattern (or an array of patterns) to match, for example "package.json" or "*.launch". Exclusion patterns start with \'!\''
+                    )),
+                    items: {
+                        type: ['string']
+                    }
+                },
+                url: {
+                    description: ( nls.localize(
+                        'contributes.jsonValidation.url',
+                        'A schema URL (\'http:\', \'https:\') or relative path to the extension folder (\'./\').'
+                    )),
+                    type: 'string'
+                }
+            }
+        }
+    }
+}));
+class JSONValidationExtensionPoint {
+    constructor() {
+        configurationExtPoint.setHandler((extensions) => {
+            for (const extension of extensions) {
+                const extensionValue = extension.value;
+                const collector = extension.collector;
+                const extensionLocation = extension.description.extensionLocation;
+                if (!extensionValue || !Array.isArray(extensionValue)) {
+                    collector.error(( nls.localize('invalid.jsonValidation', "'configuration.jsonValidation' must be a array")));
+                    return;
+                }
+                extensionValue.forEach(extension => {
+                    if (!isString(extension.fileMatch) && !(Array.isArray(extension.fileMatch) && extension.fileMatch.every(isString))) {
+                        collector.error(( nls.localize(
+                            'invalid.fileMatch',
+                            "'configuration.jsonValidation.fileMatch' must be defined as a string or an array of strings."
+                        )));
+                        return;
+                    }
+                    const uri = extension.url;
+                    if (!isString(uri)) {
+                        collector.error(( nls.localize(
+                            'invalid.url',
+                            "'configuration.jsonValidation.url' must be a URL or relative path"
+                        )));
+                        return;
+                    }
+                    if (uri.startsWith('./')) {
+                        try {
+                            const colorThemeLocation = resources.joinPath(extensionLocation, uri);
+                            if (!resources.isEqualOrParent(colorThemeLocation, extensionLocation)) {
+                                collector.warn(( nls.localize(
+                                    'invalid.path.1',
+                                    "Expected `contributes.{0}.url` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
+                                    configurationExtPoint.name,
+                                    ( colorThemeLocation.toString()),
+                                    extensionLocation.path
+                                )));
+                            }
+                        }
+                        catch (e) {
+                            collector.error(( nls.localize(
+                                'invalid.url.fileschema',
+                                "'configuration.jsonValidation.url' is an invalid relative URL: {0}",
+                                e.message
+                            )));
+                        }
+                    }
+                    else if (!/^[^:/?#]+:\/\//.test(uri)) {
+                        collector.error(( nls.localize(
+                            'invalid.url.schema',
+                            "'configuration.jsonValidation.url' must be an absolute URL or start with './'  to reference schemas located in the extension."
+                        )));
+                        return;
+                    }
+                });
+            }
+        });
+    }
+}
+export { JSONValidationExtensionPoint };

package/dist/vscode/vs/workbench/api/common/shared/dataTransferCache.js

@@ -0,0 +1,36 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+class DataTransferCache {
+    constructor() {
+        this.requestIdPool = 0;
+        this.dataTransfers = ( new Map());
+    }
+    add(dataTransfer) {
+        const requestId = this.requestIdPool++;
+        this.dataTransfers.set(requestId, [...( dataTransfer.values())]);
+        return {
+            id: requestId,
+            dispose: () => {
+                this.dataTransfers.delete(requestId);
+            }
+        };
+    }
+    async resolveDropFileData(requestId, dataItemId) {
+        const entry = this.dataTransfers.get(requestId);
+        if (!entry) {
+            throw new Error('No data transfer found');
+        }
+        const item = entry.find(x => x.id === dataItemId);
+        if (!item) {
+            throw new Error('No item found in data transfer');
+        }
+        const file = item.asFile();
+        if (!file) {
+            throw new Error('Found data transfer item is not a file');
+        }
+        return VSBuffer.wrap(await file.data());
+    }
+    dispose() {
+        this.dataTransfers.clear();
+    }
+}
+export { DataTransferCache };