@codingame/monaco-vscode-files-service-override 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -0,0 +1,404 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { TextFileEditorModel } from 'vscode/vscode/vs/workbench/services/textfile/common/textFileEditorModel';
+import { Disposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { TextFileSaveParticipant } from './textFileSaveParticipant.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { joinPath, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { createTextBufferFactoryFromSnapshot } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+
+let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
+    get models() {
+        return [...( this.mapResourceToModel.values())];
+    }
+    constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this.notificationService = notificationService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidCreate = this._register(( new Emitter()));
+        this.onDidCreate = this._onDidCreate.event;
+        this._onDidResolve = this._register(( new Emitter()));
+        this.onDidResolve = this._onDidResolve.event;
+        this._onDidRemove = this._register(( new Emitter()));
+        this.onDidRemove = this._onDidRemove.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidSaveError = this._register(( new Emitter()));
+        this.onDidSaveError = this._onDidSaveError.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this.mapResourceToModel = ( new ResourceMap());
+        this.mapResourceToModelListeners = ( new ResourceMap());
+        this.mapResourceToDisposeListener = ( new ResourceMap());
+        this.mapResourceToPendingModelResolvers = ( new ResourceMap());
+        this.modelResolveQueue = this._register(( new ResourceQueue()));
+        this.saveErrorHandler = (() => {
+            const notificationService = this.notificationService;
+            return {
+                onSaveError(error, model) {
+                    notificationService.error(( localizeWithPath(
+                        'vs/workbench/services/textfile/common/textFileEditorModelManager',
+                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
+                        "Failed to save '{0}': {1}",
+                        model.name,
+                        toErrorMessage(error, false)
+                    )));
+                }
+            };
+        })();
+        this.mapCorrelationIdToModelsToRestore = ( new Map());
+        this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
+        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
+    }
+    onDidFilesChange(e) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (e.contains(model.resource, 0 , 1 )) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    onDidChangeFileSystemProviderCapabilities(e) {
+        this.queueModelReloads(e.scheme);
+    }
+    onDidChangeFileSystemProviderRegistrations(e) {
+        if (!e.added) {
+            return;
+        }
+        this.queueModelReloads(e.scheme);
+    }
+    queueModelReloads(scheme) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (scheme === model.resource.scheme) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    queueModelReload(model) {
+        const queue = this.modelResolveQueue.queueFor(model.resource);
+        if (queue.size <= 1) {
+            queue.queue(async () => {
+                try {
+                    await this.reload(model);
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                }
+            });
+        }
+    }
+    onWillRunWorkingCopyFileOperation(e) {
+        if (e.operation === 2  || e.operation === 3 ) {
+            const modelsToRestore = [];
+            for (const { source, target } of e.files) {
+                if (source) {
+                    if (this.uriIdentityService.extUri.isEqual(source, target)) {
+                        continue;
+                    }
+                    const sourceModels = [];
+                    for (const model of this.models) {
+                        if (this.uriIdentityService.extUri.isEqualOrParent(model.resource, source)) {
+                            sourceModels.push(model);
+                        }
+                    }
+                    for (const sourceModel of sourceModels) {
+                        const sourceModelResource = sourceModel.resource;
+                        let targetModelResource;
+                        if (this.uriIdentityService.extUri.isEqual(sourceModelResource, source)) {
+                            targetModelResource = target;
+                        }
+                        else {
+                            targetModelResource = joinPath(target, sourceModelResource.path.substr(source.path.length + 1));
+                        }
+                        modelsToRestore.push({
+                            source: sourceModelResource,
+                            target: targetModelResource,
+                            languageId: sourceModel.getLanguageId(),
+                            encoding: sourceModel.getEncoding(),
+                            snapshot: sourceModel.isDirty() ? sourceModel.createSnapshot() : undefined
+                        });
+                    }
+                }
+            }
+            this.mapCorrelationIdToModelsToRestore.set(e.correlationId, modelsToRestore);
+        }
+    }
+    onDidFailWorkingCopyFileOperation(e) {
+        if (((e.operation === 2  || e.operation === 3) )) {
+            const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+            if (modelsToRestore) {
+                this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                modelsToRestore.forEach(model => {
+                    if (model.snapshot) {
+                        this.get(model.source)?.setDirty(true);
+                    }
+                });
+            }
+        }
+    }
+    onDidRunWorkingCopyFileOperation(e) {
+        switch (e.operation) {
+            case 0 :
+                e.waitUntil((async () => {
+                    for (const { target } of e.files) {
+                        const model = this.get(target);
+                        if (model && !model.isDisposed()) {
+                            await model.revert();
+                        }
+                    }
+                })());
+                break;
+            case 2 :
+            case 3 :
+                e.waitUntil((async () => {
+                    const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+                    if (modelsToRestore) {
+                        this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                        await Promises.settled(( modelsToRestore.map(async (modelToRestore) => {
+                            const restoredModel = await this.resolve(modelToRestore.target, {
+                                reload: { async: false },
+                                contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
+                                encoding: modelToRestore.encoding
+                            });
+                            if (modelToRestore.languageId &&
+                                modelToRestore.languageId !== PLAINTEXT_LANGUAGE_ID &&
+                                restoredModel.getLanguageId() === PLAINTEXT_LANGUAGE_ID &&
+                                extname(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
+                                restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
+                            }
+                        })));
+                    }
+                })());
+                break;
+        }
+    }
+    get(resource) {
+        return this.mapResourceToModel.get(resource);
+    }
+    has(resource) {
+        return ( this.mapResourceToModel.has(resource));
+    }
+    async reload(model) {
+        await this.joinPendingResolves(model.resource);
+        if (model.isDirty() || model.isDisposed() || !( this.has(model.resource))) {
+            return;
+        }
+        await this.doResolve(model, { reload: { async: false } });
+    }
+    async resolve(resource, options) {
+        const pendingResolve = this.joinPendingResolves(resource);
+        if (pendingResolve) {
+            await pendingResolve;
+        }
+        return this.doResolve(resource, options);
+    }
+    async doResolve(resourceOrModel, options) {
+        let model;
+        let resource;
+        if (URI.isUri(resourceOrModel)) {
+            resource = resourceOrModel;
+            model = this.get(resource);
+        }
+        else {
+            resource = resourceOrModel.resource;
+            model = resourceOrModel;
+        }
+        let modelResolve;
+        let didCreateModel = false;
+        if (model) {
+            if (options?.contents) {
+                modelResolve = model.resolve(options);
+            }
+            else if (options?.reload) {
+                if (options.reload.async) {
+                    modelResolve = Promise.resolve();
+                    (async () => {
+                        try {
+                            await model.resolve(options);
+                        }
+                        catch (error) {
+                            onUnexpectedError(error);
+                        }
+                    })();
+                }
+                else {
+                    modelResolve = model.resolve(options);
+                }
+            }
+            else {
+                modelResolve = Promise.resolve();
+            }
+        }
+        else {
+            didCreateModel = true;
+            const newModel = model = this.instantiationService.createInstance(TextFileEditorModel, resource, options ? options.encoding : undefined, options ? options.languageId : undefined);
+            modelResolve = model.resolve(options);
+            this.registerModel(newModel);
+        }
+        this.mapResourceToPendingModelResolvers.set(resource, modelResolve);
+        this.add(resource, model);
+        if (didCreateModel) {
+            this._onDidCreate.fire(model);
+            if (model.isDirty()) {
+                this._onDidChangeDirty.fire(model);
+            }
+        }
+        try {
+            await modelResolve;
+        }
+        catch (error) {
+            if (didCreateModel) {
+                model.dispose();
+            }
+            throw error;
+        }
+        finally {
+            this.mapResourceToPendingModelResolvers.delete(resource);
+        }
+        if (options?.languageId) {
+            model.setLanguageId(options.languageId);
+        }
+        if (didCreateModel && model.isDirty()) {
+            this._onDidChangeDirty.fire(model);
+        }
+        return model;
+    }
+    joinPendingResolves(resource) {
+        const pendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+        if (!pendingModelResolve) {
+            return;
+        }
+        return this.doJoinPendingResolves(resource);
+    }
+    async doJoinPendingResolves(resource) {
+        let currentModelCopyResolve;
+        while (( this.mapResourceToPendingModelResolvers.has(resource))) {
+            const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+            if (nextPendingModelResolve === currentModelCopyResolve) {
+                return;
+            }
+            currentModelCopyResolve = nextPendingModelResolve;
+            try {
+                await nextPendingModelResolve;
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerModel(model) {
+        const modelListeners = ( new DisposableStore());
+        modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
+        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
+        modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
+        modelListeners.add(model.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(model)));
+        modelListeners.add(model.onDidSaveError(() => this._onDidSaveError.fire(model)));
+        modelListeners.add(model.onDidSave(e => this._onDidSave.fire({ model, ...e })));
+        modelListeners.add(model.onDidRevert(() => this._onDidRevert.fire(model)));
+        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
+        this.mapResourceToModelListeners.set(model.resource, modelListeners);
+    }
+    add(resource, model) {
+        const knownModel = this.mapResourceToModel.get(resource);
+        if (knownModel === model) {
+            return;
+        }
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        disposeListener?.dispose();
+        this.mapResourceToModel.set(resource, model);
+        this.mapResourceToDisposeListener.set(resource, model.onWillDispose(() => this.remove(resource)));
+    }
+    remove(resource) {
+        const removed = this.mapResourceToModel.delete(resource);
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        if (disposeListener) {
+            dispose(disposeListener);
+            this.mapResourceToDisposeListener.delete(resource);
+        }
+        const modelListener = this.mapResourceToModelListeners.get(resource);
+        if (modelListener) {
+            dispose(modelListener);
+            this.mapResourceToModelListeners.delete(resource);
+        }
+        if (removed) {
+            this._onDidRemove.fire(resource);
+        }
+    }
+    addSaveParticipant(participant) {
+        return this.saveParticipants.addSaveParticipant(participant);
+    }
+    runSaveParticipants(model, context, token) {
+        return this.saveParticipants.participate(model, context, token);
+    }
+    canDispose(model) {
+        if (model.isDisposed() ||
+            (!( this.mapResourceToPendingModelResolvers.has(model.resource)) && !model.isDirty())) {
+            return true;
+        }
+        return this.doCanDispose(model);
+    }
+    async doCanDispose(model) {
+        const pendingResolve = this.joinPendingResolves(model.resource);
+        if (pendingResolve) {
+            await pendingResolve;
+            return this.canDispose(model);
+        }
+        if (model.isDirty()) {
+            await Event.toPromise(model.onDidChangeDirty);
+            return this.canDispose(model);
+        }
+        return true;
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToModel.clear();
+        this.mapResourceToPendingModelResolvers.clear();
+        dispose(( this.mapResourceToDisposeListener.values()));
+        this.mapResourceToDisposeListener.clear();
+        dispose(( this.mapResourceToModelListeners.values()));
+        this.mapResourceToModelListeners.clear();
+    }
+};
+TextFileEditorModelManager = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IWorkingCopyFileService)),
+    ( __param(4, IUriIdentityService))
+], TextFileEditorModelManager));
+
+export { TextFileEditorModelManager };

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -0,0 +1,64 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { insert } from 'monaco-editor/esm/vs/base/common/arrays.js';
+
+let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
+    constructor(progressService, logService) {
+        super();
+        this.progressService = progressService;
+        this.logService = logService;
+        this.saveParticipants = [];
+    }
+    addSaveParticipant(participant) {
+        const remove = insert(this.saveParticipants, participant);
+        return toDisposable(() => remove());
+    }
+    participate(model, context, token) {
+        const cts = ( new CancellationTokenSource(token));
+        return this.progressService.withProgress({
+            title: ( localizeWithPath(
+                'vs/workbench/services/textfile/common/textFileSaveParticipant',
+                'saveParticipants',
+                "Saving '{0}'",
+                model.name
+            )),
+            location: 15 ,
+            cancellable: true,
+            delay: model.isDirty() ? 3000 : 5000
+        }, async (progress) => {
+            model.textEditorModel?.pushStackElement();
+            for (const saveParticipant of this.saveParticipants) {
+                if (cts.token.isCancellationRequested || !model.textEditorModel ) {
+                    break;
+                }
+                try {
+                    const promise = saveParticipant.participate(model, context, progress, cts.token);
+                    await raceCancellation(promise, cts.token);
+                }
+                catch (err) {
+                    this.logService.error(err);
+                }
+            }
+            model.textEditorModel?.pushStackElement();
+        }, () => {
+            cts.cancel();
+        }).finally(() => {
+            cts.dispose();
+        });
+    }
+    dispose() {
+        this.saveParticipants.splice(0, this.saveParticipants.length);
+        super.dispose();
+    }
+};
+TextFileSaveParticipant = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, ILogService))
+], TextFileSaveParticipant));
+
+export { TextFileSaveParticipant };

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -1,222 +0,0 @@
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import { newWriteableStream } from 'monaco-editor/esm/vs/base/common/stream.js';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-
-class File {
-    constructor(name) {
-        this.type = FileType.File;
-        this.ctime = Date.now();
-        this.mtime = Date.now();
-        this.size = 0;
-        this.name = name;
-    }
-}
-class Directory {
-    constructor(name) {
-        this.type = FileType.Directory;
-        this.ctime = Date.now();
-        this.mtime = Date.now();
-        this.size = 0;
-        this.name = name;
-        this.entries = ( new Map());
-    }
-}
-class InMemoryFileSystemProvider extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.memoryFdCounter = 0;
-        this.fdMemory = ( new Map());
-        this._onDidChangeCapabilities = this._register(( new Emitter()));
-        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
-        this._capabilities = 2  | 1024 ;
-        this.root = ( new Directory(''));
-        this._onDidChangeFile = this._register(( new Emitter()));
-        this.onDidChangeFile = this._onDidChangeFile.event;
-        this._bufferedChanges = [];
-    }
-    get capabilities() { return this._capabilities; }
-    setReadOnly(readonly) {
-        const isReadonly = !!((this._capabilities & 2048) );
-        if (readonly !== isReadonly) {
-            this._capabilities = readonly ? 2048  | 1024  | 2
-                : 2  | 1024 ;
-            this._onDidChangeCapabilities.fire();
-        }
-    }
-    async stat(resource) {
-        return this._lookup(resource, false);
-    }
-    async readdir(resource) {
-        const entry = this._lookupAsDirectory(resource, false);
-        const result = [];
-        entry.entries.forEach((child, name) => result.push([name, child.type]));
-        return result;
-    }
-    async readFile(resource) {
-        const data = this._lookupAsFile(resource, false).data;
-        if (data) {
-            return data;
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    readFileStream(resource) {
-        const data = this._lookupAsFile(resource, false).data;
-        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
-        stream.end(data);
-        return stream;
-    }
-    async writeFile(resource, content, opts) {
-        const basename = resources.basename(resource);
-        const parent = this._lookupParentDirectory(resource);
-        let entry = parent.entries.get(basename);
-        if (entry instanceof Directory) {
-            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
-        }
-        if (!entry && !opts.create) {
-            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-        }
-        if (entry && opts.create && !opts.overwrite) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        if (!entry) {
-            entry = ( new File(basename));
-            parent.entries.set(basename, entry);
-            this._fireSoon({ type: 1 , resource });
-        }
-        entry.mtime = Date.now();
-        entry.size = content.byteLength;
-        entry.data = content;
-        this._fireSoon({ type: 0 , resource });
-    }
-    open(resource, opts) {
-        const data = this._lookupAsFile(resource, false).data;
-        if (data) {
-            const fd = this.memoryFdCounter++;
-            this.fdMemory.set(fd, data);
-            return Promise.resolve(fd);
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    close(fd) {
-        this.fdMemory.delete(fd);
-        return Promise.resolve();
-    }
-    read(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
-        data.set(toWrite.buffer, offset);
-        return Promise.resolve(toWrite.byteLength);
-    }
-    write(fd, pos, data, offset, length) {
-        const memory = this.fdMemory.get(fd);
-        if (!memory) {
-            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
-        }
-        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
-        memory.set(toWrite.buffer, pos);
-        return Promise.resolve(toWrite.byteLength);
-    }
-    async rename(from, to, opts) {
-        if (!opts.overwrite && this._lookup(to, true)) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        const entry = this._lookup(from, false);
-        const oldParent = this._lookupParentDirectory(from);
-        const newParent = this._lookupParentDirectory(to);
-        const newName = resources.basename(to);
-        oldParent.entries.delete(entry.name);
-        entry.name = newName;
-        newParent.entries.set(newName, entry);
-        this._fireSoon({ type: 2 , resource: from }, { type: 1 , resource: to });
-    }
-    async delete(resource, opts) {
-        const dirname = resources.dirname(resource);
-        const basename = resources.basename(resource);
-        const parent = this._lookupAsDirectory(dirname, false);
-        if (( parent.entries.has(basename))) {
-            parent.entries.delete(basename);
-            parent.mtime = Date.now();
-            parent.size -= 1;
-            this._fireSoon({ type: 0 , resource: dirname }, { resource, type: 2  });
-        }
-    }
-    async mkdir(resource) {
-        if (this._lookup(resource, true)) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        const basename = resources.basename(resource);
-        const dirname = resources.dirname(resource);
-        const parent = this._lookupAsDirectory(dirname, false);
-        const entry = ( new Directory(basename));
-        parent.entries.set(entry.name, entry);
-        parent.mtime = Date.now();
-        parent.size += 1;
-        this._fireSoon({ type: 0 , resource: dirname }, { type: 1 , resource });
-    }
-    _lookup(uri, silent) {
-        const parts = uri.path.split('/');
-        let entry = this.root;
-        for (const part of parts) {
-            if (!part) {
-                continue;
-            }
-            let child;
-            if (entry instanceof Directory) {
-                child = entry.entries.get(part);
-            }
-            if (!child) {
-                if (!silent) {
-                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-                }
-                else {
-                    return undefined;
-                }
-            }
-            entry = child;
-        }
-        return entry;
-    }
-    _lookupAsDirectory(uri, silent) {
-        const entry = this._lookup(uri, silent);
-        if (entry instanceof Directory) {
-            return entry;
-        }
-        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
-    }
-    _lookupAsFile(uri, silent) {
-        const entry = this._lookup(uri, silent);
-        if (entry instanceof File) {
-            return entry;
-        }
-        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
-    }
-    _lookupParentDirectory(uri) {
-        const dirname = resources.dirname(uri);
-        return this._lookupAsDirectory(dirname, false);
-    }
-    watch(resource, opts) {
-        return Disposable.None;
-    }
-    _fireSoon(...changes) {
-        this._bufferedChanges.push(...changes);
-        if (this._fireSoonHandle) {
-            clearTimeout(this._fireSoonHandle);
-        }
-        this._fireSoonHandle = setTimeout(() => {
-            this._onDidChangeFile.fire(this._bufferedChanges);
-            this._bufferedChanges.length = 0;
-        }, 5);
-    }
-    dispose() {
-        super.dispose();
-        this.fdMemory.clear();
-    }
-}
-
-export { InMemoryFileSystemProvider };