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

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

@@ -0,0 +1,272 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { FileChangeType } from './extHostTypes.js';
+import { DocumentLink } from './extHostTypeConverters.js';
+import { StateMachine, LinkComputer } from 'monaco-editor/esm/vs/editor/common/languages/linkComputer.js';
+import { commonPrefixLength } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+class FsLinkProvider {
+    constructor() {
+        this._schemes = [];
+    }
+    add(scheme) {
+        this._stateMachine = undefined;
+        this._schemes.push(scheme);
+    }
+    delete(scheme) {
+        const idx = this._schemes.indexOf(scheme);
+        if (idx >= 0) {
+            this._schemes.splice(idx, 1);
+            this._stateMachine = undefined;
+        }
+    }
+    _initStateMachine() {
+        if (!this._stateMachine) {
+            const schemes = this._schemes.sort();
+            const edges = [];
+            let prevScheme;
+            let prevState;
+            let lastState = 14 ;
+            let nextState = 14 ;
+            for (const scheme of schemes) {
+                let pos = !prevScheme ? 0 : commonPrefixLength(prevScheme, scheme);
+                if (pos === 0) {
+                    prevState = 1 ;
+                }
+                else {
+                    prevState = nextState;
+                }
+                for (; pos < scheme.length; pos++) {
+                    if (pos + 1 === scheme.length) {
+                        lastState = nextState;
+                        nextState = 9 ;
+                    }
+                    else {
+                        nextState += 1;
+                    }
+                    edges.push([prevState, scheme.toUpperCase().charCodeAt(pos), nextState]);
+                    edges.push([prevState, scheme.toLowerCase().charCodeAt(pos), nextState]);
+                    prevState = nextState;
+                }
+                prevScheme = scheme;
+                nextState = lastState;
+            }
+            edges.push([9 , 58 , 10 ]);
+            edges.push([10 , 47 , 12 ]);
+            this._stateMachine = ( new StateMachine(edges));
+        }
+    }
+    provideDocumentLinks(document) {
+        this._initStateMachine();
+        const result = [];
+        const links = LinkComputer.computeLinks({
+            getLineContent(lineNumber) {
+                return document.lineAt(lineNumber - 1).text;
+            },
+            getLineCount() {
+                return document.lineCount;
+            }
+        }, this._stateMachine);
+        for (const link of links) {
+            const docLink = DocumentLink.to(link);
+            if (docLink.target) {
+                result.push(docLink);
+            }
+        }
+        return result;
+    }
+}
+class ExtHostFileSystem {
+    constructor(mainContext, _extHostLanguageFeatures) {
+        this._extHostLanguageFeatures = _extHostLanguageFeatures;
+        this._linkProvider = ( new FsLinkProvider());
+        this._fsProvider = ( new Map());
+        this._registeredSchemes = ( new Set());
+        this._watches = ( new Map());
+        this._handlePool = 0;
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadFileSystem));
+    }
+    dispose() {
+        this._linkProviderRegistration?.dispose();
+    }
+    registerFileSystemProvider(extension, scheme, provider, options = {}) {
+        ExtHostFileSystem._validateFileSystemProvider(provider);
+        if (this._registeredSchemes.has(scheme)) {
+            throw new Error(`a provider for the scheme '${scheme}' is already registered`);
+        }
+        if (!this._linkProviderRegistration) {
+            this._linkProviderRegistration = this._extHostLanguageFeatures.registerDocumentLinkProvider(extension, '*', this._linkProvider);
+        }
+        const handle = this._handlePool++;
+        this._linkProvider.add(scheme);
+        this._registeredSchemes.add(scheme);
+        this._fsProvider.set(handle, provider);
+        let capabilities = 2 ;
+        if (options.isCaseSensitive) {
+            capabilities += 1024 ;
+        }
+        if (options.isReadonly) {
+            capabilities += 2048 ;
+        }
+        if (typeof provider.copy === 'function') {
+            capabilities += 8 ;
+        }
+        if (typeof provider.open === 'function' && typeof provider.close === 'function'
+            && typeof provider.read === 'function' && typeof provider.write === 'function') {
+            checkProposedApiEnabled(extension, 'fsChunks');
+            capabilities += 4 ;
+        }
+        this._proxy.$registerFileSystemProvider(handle, scheme, capabilities).catch(err => {
+            console.error(`FAILED to register filesystem provider of ${extension.identifier.value}-extension for the scheme ${scheme}`);
+            console.error(err);
+        });
+        const subscription = provider.onDidChangeFile(event => {
+            const mapped = [];
+            for (const e of event) {
+                const { uri: resource, type } = e;
+                if (resource.scheme !== scheme) {
+                    continue;
+                }
+                let newType;
+                switch (type) {
+                    case FileChangeType.Changed:
+                        newType = 0 ;
+                        break;
+                    case FileChangeType.Created:
+                        newType = 1 ;
+                        break;
+                    case FileChangeType.Deleted:
+                        newType = 2 ;
+                        break;
+                    default:
+                        throw new Error('Unknown FileChangeType');
+                }
+                mapped.push({ resource, type: newType });
+            }
+            this._proxy.$onFileSystemChange(handle, mapped);
+        });
+        return toDisposable(() => {
+            subscription.dispose();
+            this._linkProvider.delete(scheme);
+            this._registeredSchemes.delete(scheme);
+            this._fsProvider.delete(handle);
+            this._proxy.$unregisterProvider(handle);
+        });
+    }
+    static _validateFileSystemProvider(provider) {
+        if (!provider) {
+            throw new Error('MISSING provider');
+        }
+        if (typeof provider.watch !== 'function') {
+            throw new Error('Provider does NOT implement watch');
+        }
+        if (typeof provider.stat !== 'function') {
+            throw new Error('Provider does NOT implement stat');
+        }
+        if (typeof provider.readDirectory !== 'function') {
+            throw new Error('Provider does NOT implement readDirectory');
+        }
+        if (typeof provider.createDirectory !== 'function') {
+            throw new Error('Provider does NOT implement createDirectory');
+        }
+        if (typeof provider.readFile !== 'function') {
+            throw new Error('Provider does NOT implement readFile');
+        }
+        if (typeof provider.writeFile !== 'function') {
+            throw new Error('Provider does NOT implement writeFile');
+        }
+        if (typeof provider.delete !== 'function') {
+            throw new Error('Provider does NOT implement delete');
+        }
+        if (typeof provider.rename !== 'function') {
+            throw new Error('Provider does NOT implement rename');
+        }
+    }
+    static _asIStat(stat) {
+        const { type, ctime, mtime, size, permissions } = stat;
+        return { type, ctime, mtime, size, permissions };
+    }
+    $stat(handle, resource) {
+        return Promise.resolve(this._getFsProvider(handle).stat(URI.revive(resource))).then(stat => ExtHostFileSystem._asIStat(stat));
+    }
+    $readdir(handle, resource) {
+        return Promise.resolve(this._getFsProvider(handle).readDirectory(URI.revive(resource)));
+    }
+    $readFile(handle, resource) {
+        return Promise.resolve(this._getFsProvider(handle).readFile(URI.revive(resource))).then(data => VSBuffer.wrap(data));
+    }
+    $writeFile(handle, resource, content, opts) {
+        return Promise.resolve(this._getFsProvider(handle).writeFile(URI.revive(resource), content.buffer, opts));
+    }
+    $delete(handle, resource, opts) {
+        return Promise.resolve(this._getFsProvider(handle).delete(URI.revive(resource), opts));
+    }
+    $rename(handle, oldUri, newUri, opts) {
+        return Promise.resolve(this._getFsProvider(handle).rename(URI.revive(oldUri), URI.revive(newUri), opts));
+    }
+    $copy(handle, oldUri, newUri, opts) {
+        const provider = this._getFsProvider(handle);
+        if (!provider.copy) {
+            throw new Error('FileSystemProvider does not implement "copy"');
+        }
+        return Promise.resolve(provider.copy(URI.revive(oldUri), URI.revive(newUri), opts));
+    }
+    $mkdir(handle, resource) {
+        return Promise.resolve(this._getFsProvider(handle).createDirectory(URI.revive(resource)));
+    }
+    $watch(handle, session, resource, opts) {
+        const subscription = this._getFsProvider(handle).watch(URI.revive(resource), opts);
+        this._watches.set(session, subscription);
+    }
+    $unwatch(_handle, session) {
+        const subscription = this._watches.get(session);
+        if (subscription) {
+            subscription.dispose();
+            this._watches.delete(session);
+        }
+    }
+    $open(handle, resource, opts) {
+        const provider = this._getFsProvider(handle);
+        if (!provider.open) {
+            throw new Error('FileSystemProvider does not implement "open"');
+        }
+        return Promise.resolve(provider.open(URI.revive(resource), opts));
+    }
+    $close(handle, fd) {
+        const provider = this._getFsProvider(handle);
+        if (!provider.close) {
+            throw new Error('FileSystemProvider does not implement "close"');
+        }
+        return Promise.resolve(provider.close(fd));
+    }
+    $read(handle, fd, pos, length) {
+        const provider = this._getFsProvider(handle);
+        if (!provider.read) {
+            throw new Error('FileSystemProvider does not implement "read"');
+        }
+        const data = VSBuffer.alloc(length);
+        return Promise.resolve(provider.read(fd, pos, data.buffer, 0, length)).then(read => {
+            return data.slice(0, read);
+        });
+    }
+    $write(handle, fd, pos, data) {
+        const provider = this._getFsProvider(handle);
+        if (!provider.write) {
+            throw new Error('FileSystemProvider does not implement "write"');
+        }
+        return Promise.resolve(provider.write(fd, pos, data.buffer, 0, data.byteLength));
+    }
+    _getFsProvider(handle) {
+        const provider = this._fsProvider.get(handle);
+        if (!provider) {
+            const err = ( new Error());
+            err.name = 'ENOPRO';
+            err.message = `no provider`;
+            throw err;
+        }
+        return provider;
+    }
+}
+export { ExtHostFileSystem };

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

@@ -0,0 +1,153 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { MainContext } from './extHost.protocol.js';
+import * as files from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { FileSystemError } from './extHostTypes.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostFileSystemInfo } from './extHostFileSystemInfo.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+let ExtHostConsumerFileSystem = class ExtHostConsumerFileSystem {
+    constructor(extHostRpc, fileSystemInfo) {
+        this._fileSystemProvider = ( new Map());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadFileSystem));
+        const that = this;
+        this.value = ( Object.freeze({
+            async stat(uri) {
+                try {
+                    const provider = that._fileSystemProvider.get(uri.scheme);
+                    if (!provider) {
+                        return await that._proxy.$stat(uri);
+                    }
+                    await that._proxy.$ensureActivation(uri.scheme);
+                    const stat = await provider.stat(uri);
+                    return {
+                        type: stat.type,
+                        ctime: stat.ctime,
+                        mtime: stat.mtime,
+                        size: stat.size,
+                        permissions: stat.permissions
+                    };
+                }
+                catch (err) {
+                    ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async readDirectory(uri) {
+                try {
+                    const provider = that._fileSystemProvider.get(uri.scheme);
+                    if (provider) {
+                        await that._proxy.$ensureActivation(uri.scheme);
+                        return (await provider.readDirectory(uri)).slice();
+                    }
+                    else {
+                        return await that._proxy.$readdir(uri);
+                    }
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async createDirectory(uri) {
+                try {
+                    return await that._proxy.$mkdir(uri);
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async readFile(uri) {
+                try {
+                    const provider = that._fileSystemProvider.get(uri.scheme);
+                    if (provider) {
+                        await that._proxy.$ensureActivation(uri.scheme);
+                        return (await provider.readFile(uri)).slice();
+                    }
+                    else {
+                        const buff = await that._proxy.$readFile(uri);
+                        return buff.buffer;
+                    }
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async writeFile(uri, content) {
+                try {
+                    return await that._proxy.$writeFile(uri, VSBuffer.wrap(content));
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async delete(uri, options) {
+                try {
+                    const provider = that._fileSystemProvider.get(uri.scheme);
+                    if (provider) {
+                        await that._proxy.$ensureActivation(uri.scheme);
+                        return await provider.delete(uri, { recursive: false, ...options });
+                    }
+                    else {
+                        return await that._proxy.$delete(uri, { recursive: false, useTrash: false, ...options });
+                    }
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async rename(oldUri, newUri, options) {
+                try {
+                    return await that._proxy.$rename(oldUri, newUri, { ...{ overwrite: false }, ...options });
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            async copy(source, destination, options) {
+                try {
+                    return await that._proxy.$copy(source, destination, { ...{ overwrite: false }, ...options });
+                }
+                catch (err) {
+                    return ExtHostConsumerFileSystem._handleError(err);
+                }
+            },
+            isWritableFileSystem(scheme) {
+                const capabilities = fileSystemInfo.getCapabilities(scheme);
+                if (typeof capabilities === 'number') {
+                    return !((capabilities & 2048) );
+                }
+                return undefined;
+            }
+        }));
+    }
+    static _handleError(err) {
+        if (err instanceof FileSystemError) {
+            throw err;
+        }
+        if (!(err instanceof Error)) {
+            throw new FileSystemError(String(err));
+        }
+        if (err.name === 'ENOPRO' || err.message.includes('ENOPRO')) {
+            throw FileSystemError.Unavailable(err.message);
+        }
+        switch (err.name) {
+            case files.FileSystemProviderErrorCode.FileExists: throw FileSystemError.FileExists(err.message);
+            case files.FileSystemProviderErrorCode.FileNotFound: throw FileSystemError.FileNotFound(err.message);
+            case files.FileSystemProviderErrorCode.FileNotADirectory: throw FileSystemError.FileNotADirectory(err.message);
+            case files.FileSystemProviderErrorCode.FileIsADirectory: throw FileSystemError.FileIsADirectory(err.message);
+            case files.FileSystemProviderErrorCode.NoPermissions: throw FileSystemError.NoPermissions(err.message);
+            case files.FileSystemProviderErrorCode.Unavailable: throw FileSystemError.Unavailable(err.message);
+            default: throw new FileSystemError(err.message, err.name);
+        }
+    }
+    addFileSystemProvider(scheme, provider) {
+        this._fileSystemProvider.set(scheme, provider);
+        return toDisposable(() => this._fileSystemProvider.delete(scheme));
+    }
+};
+ExtHostConsumerFileSystem = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostFileSystemInfo))
+], ExtHostConsumerFileSystem));
+const IExtHostConsumerFileSystem = ( createDecorator('IExtHostConsumerFileSystem'));
+export { ExtHostConsumerFileSystem, IExtHostConsumerFileSystem };

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

@@ -0,0 +1,193 @@
+import { Emitter, AsyncEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { parse, GLOBSTAR, GLOB_SPLIT } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { GlobPattern, WorkspaceEdit as WorkspaceEdit$1 } from './extHostTypeConverters.js';
+import { WorkspaceEdit, Disposable } from './extHostTypes.js';
+class FileSystemWatcher {
+    get ignoreCreateEvents() {
+        return Boolean(this._config & 0b001);
+    }
+    get ignoreChangeEvents() {
+        return Boolean(this._config & 0b010);
+    }
+    get ignoreDeleteEvents() {
+        return Boolean(this._config & 0b100);
+    }
+    constructor(mainContext, workspace, extension, dispatcher, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents) {
+        this._onDidCreate = ( new Emitter());
+        this._onDidChange = ( new Emitter());
+        this._onDidDelete = ( new Emitter());
+        const watcherDisposable = this.ensureWatching(mainContext, extension, globPattern);
+        this._config = 0;
+        if (ignoreCreateEvents) {
+            this._config += 0b001;
+        }
+        if (ignoreChangeEvents) {
+            this._config += 0b010;
+        }
+        if (ignoreDeleteEvents) {
+            this._config += 0b100;
+        }
+        const parsedPattern = parse(globPattern);
+        const excludeOutOfWorkspaceEvents = typeof globPattern === 'string';
+        const subscription = dispatcher(events => {
+            if (!ignoreCreateEvents) {
+                for (const created of events.created) {
+                    const uri = URI.revive(created);
+                    if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
+                        this._onDidCreate.fire(uri);
+                    }
+                }
+            }
+            if (!ignoreChangeEvents) {
+                for (const changed of events.changed) {
+                    const uri = URI.revive(changed);
+                    if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
+                        this._onDidChange.fire(uri);
+                    }
+                }
+            }
+            if (!ignoreDeleteEvents) {
+                for (const deleted of events.deleted) {
+                    const uri = URI.revive(deleted);
+                    if (parsedPattern(uri.fsPath) && (!excludeOutOfWorkspaceEvents || workspace.getWorkspaceFolder(uri))) {
+                        this._onDidDelete.fire(uri);
+                    }
+                }
+            }
+        });
+        this._disposable = Disposable.from(watcherDisposable, this._onDidCreate, this._onDidChange, this._onDidDelete, subscription);
+    }
+    ensureWatching(mainContext, extension, globPattern) {
+        const disposable = Disposable.from();
+        if (typeof globPattern === 'string') {
+            return disposable;
+        }
+        const proxy = ( mainContext.getProxy(MainContext.MainThreadFileSystem));
+        let recursive = false;
+        if (globPattern.pattern.includes(GLOBSTAR) || globPattern.pattern.includes(GLOB_SPLIT)) {
+            recursive = true;
+        }
+        const session = Math.random();
+        proxy.$watch(extension.identifier.value, session, globPattern.baseUri, { recursive, excludes: []  });
+        return Disposable.from({ dispose: () => proxy.$unwatch(session) });
+    }
+    dispose() {
+        this._disposable.dispose();
+    }
+    get onDidCreate() {
+        return this._onDidCreate.event;
+    }
+    get onDidChange() {
+        return this._onDidChange.event;
+    }
+    get onDidDelete() {
+        return this._onDidDelete.event;
+    }
+}
+class ExtHostFileSystemEventService {
+    constructor(_mainContext, _logService, _extHostDocumentsAndEditors) {
+        this._mainContext = _mainContext;
+        this._logService = _logService;
+        this._extHostDocumentsAndEditors = _extHostDocumentsAndEditors;
+        this._onFileSystemEvent = ( new Emitter());
+        this._onDidRenameFile = ( new Emitter());
+        this._onDidCreateFile = ( new Emitter());
+        this._onDidDeleteFile = ( new Emitter());
+        this._onWillRenameFile = ( new AsyncEmitter());
+        this._onWillCreateFile = ( new AsyncEmitter());
+        this._onWillDeleteFile = ( new AsyncEmitter());
+        this.onDidRenameFile = this._onDidRenameFile.event;
+        this.onDidCreateFile = this._onDidCreateFile.event;
+        this.onDidDeleteFile = this._onDidDeleteFile.event;
+    }
+    createFileSystemWatcher(workspace, extension, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents) {
+        return ( new FileSystemWatcher(
+            this._mainContext,
+            workspace,
+            extension,
+            this._onFileSystemEvent.event,
+            GlobPattern.from(globPattern),
+            ignoreCreateEvents,
+            ignoreChangeEvents,
+            ignoreDeleteEvents
+        ));
+    }
+    $onFileEvent(events) {
+        this._onFileSystemEvent.fire(events);
+    }
+    $onDidRunFileOperation(operation, files) {
+        switch (operation) {
+            case 2 :
+                this._onDidRenameFile.fire(( Object.freeze({ files: ( files.map(f => ({ oldUri: URI.revive(f.source), newUri: URI.revive(f.target) }))) })));
+                break;
+            case 1 :
+                this._onDidDeleteFile.fire(( Object.freeze({ files: ( files.map(f => URI.revive(f.target))) })));
+                break;
+            case 0 :
+            case 3 :
+                this._onDidCreateFile.fire(( Object.freeze({ files: ( files.map(f => URI.revive(f.target))) })));
+                break;
+        }
+    }
+    getOnWillRenameFileEvent(extension) {
+        return this._createWillExecuteEvent(extension, this._onWillRenameFile);
+    }
+    getOnWillCreateFileEvent(extension) {
+        return this._createWillExecuteEvent(extension, this._onWillCreateFile);
+    }
+    getOnWillDeleteFileEvent(extension) {
+        return this._createWillExecuteEvent(extension, this._onWillDeleteFile);
+    }
+    _createWillExecuteEvent(extension, emitter) {
+        return (listener, thisArg, disposables) => {
+            const wrappedListener = function wrapped(e) { listener.call(thisArg, e); };
+            wrappedListener.extension = extension;
+            return emitter.event(wrappedListener, undefined, disposables);
+        };
+    }
+    async $onWillRunFileOperation(operation, files, timeout, token) {
+        switch (operation) {
+            case 2 :
+                return await this._fireWillEvent(this._onWillRenameFile, { files: ( files.map(f => ({ oldUri: URI.revive(f.source), newUri: URI.revive(f.target) }))) }, timeout, token);
+            case 1 :
+                return await this._fireWillEvent(this._onWillDeleteFile, { files: ( files.map(f => URI.revive(f.target))) }, timeout, token);
+            case 0 :
+            case 3 :
+                return await this._fireWillEvent(this._onWillCreateFile, { files: ( files.map(f => URI.revive(f.target))) }, timeout, token);
+        }
+        return undefined;
+    }
+    async _fireWillEvent(emitter, data, timeout, token) {
+        const extensionNames = ( new Set());
+        const edits = [];
+        await emitter.fireAsync(data, token, async (thenable, listener) => {
+            const now = Date.now();
+            const result = await Promise.resolve(thenable);
+            if (result instanceof WorkspaceEdit) {
+                edits.push([listener.extension, result]);
+                extensionNames.add(listener.extension.displayName ?? listener.extension.identifier.value);
+            }
+            if (Date.now() - now > timeout) {
+                this._logService.warn('SLOW file-participant', listener.extension.identifier);
+            }
+        });
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        if (edits.length === 0) {
+            return undefined;
+        }
+        const dto = { edits: [] };
+        for (const [, edit] of edits) {
+            const { edits } = WorkspaceEdit$1.from(edit, {
+                getTextDocumentVersion: uri => this._extHostDocumentsAndEditors.getDocument(uri)?.version,
+                getNotebookDocumentVersion: () => undefined,
+            });
+            dto.edits = dto.edits.concat(edits);
+        }
+        return { edit: dto, extensionNames: Array.from(extensionNames) };
+    }
+}
+export { ExtHostFileSystemEventService };

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

@@ -0,0 +1,35 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+class ExtHostFileSystemInfo {
+    constructor() {
+        this._systemSchemes = ( new Set(( Object.keys(Schemas))));
+        this._providerInfo = ( new Map());
+        this.extUri = ( new ExtUri(uri => {
+            const capabilities = this._providerInfo.get(uri.scheme);
+            if (capabilities === undefined) {
+                return false;
+            }
+            if (capabilities & 1024 ) {
+                return false;
+            }
+            return true;
+        }));
+    }
+    $acceptProviderInfos(uri, capabilities) {
+        if (capabilities === null) {
+            this._providerInfo.delete(uri.scheme);
+        }
+        else {
+            this._providerInfo.set(uri.scheme, capabilities);
+        }
+    }
+    isFreeScheme(scheme) {
+        return !this._providerInfo.has(scheme) && !this._systemSchemes.has(scheme);
+    }
+    getCapabilities(scheme) {
+        return this._providerInfo.get(scheme);
+    }
+}
+const IExtHostFileSystemInfo = ( createDecorator('IExtHostFileSystemInfo'));
+export { ExtHostFileSystemInfo, IExtHostFileSystemInfo };

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

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