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

package/dist/files.js

@@ -1,3167 +0,0 @@
-import { __decorate, EditorExtensions, FILES_EXCLUDE_CONFIG, FILES_ASSOCIATIONS_CONFIG, SUPPORTED_ENCODINGS, AutoSaveConfiguration, Emitter, createFileSystemProviderError, AbstractTextResourceEditorInput, DEFAULT_EDITOR_ASSOCIATION, findViewStateForEditor, isResourceEditorInput, __param, HotExitConfiguration, FileType, FileSystemProviderError, FileSystemProviderErrorCode, IFileService, ITextFileService, BrowserTextFileService, EditorModel, getLargeFileConfirmationLimit, ByteSize, IFilesConfigurationService, IEditorService, IPathService, IUriIdentityService, IHostService, ResourceQueue, mark, FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, ensureFileSystemProviderError, FilePermission, etag, FileOperationEvent, isReadableStream, peekStream, peekReadable, bufferToReadable, toFileOperationResult, ETAG_DISABLED, streamToBuffer, hasFileAtomicReadCapability, consumeStream, NotModifiedSinceFileOperationError, TooLargeFileOperationError, transform, hasFileFolderCopyCapability, hasFileCloneCapability, isReadableBufferedStream, listenStream, bufferedStreamToBuffer, readableToBuffer, isEqual as isEqual$1, CancellationTokenSource, newWriteableBufferStream, newWriteableStream } from './polyfill.js';
-export { FileChangeType$1 as FileChangeType, FileSystemProviderCapabilities } from './polyfill.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { canceled, ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Disposable, DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { RunOnceScheduler, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { basename, dirname, isEqual, relativePath, joinPath, isAbsolutePath, extUri, extUriIgnorePathCase, basenameOrAuthority, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { FILE_EDITOR_INPUT_ID, BINARY_TEXT_FILE_MODE, BINARY_FILE_EDITOR_ID, TEXT_FILE_EDITOR_ID } from './files2.js';
-import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { equalsIgnoreCase, startsWithIgnoreCase, rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
-import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IUndoRedoService, UndoRedoSource } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { isWeb, isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
-import { RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-async function readFileIntoStream(provider, resource, target, transformer, options, token) {
-    let error = undefined;
-    try {
-        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
-    }
-    catch (err) {
-        error = err;
-    }
-    finally {
-        if (error && options.errorTransformer) {
-            error = options.errorTransformer(error);
-        }
-        if (typeof error !== 'undefined') {
-            target.error(error);
-        }
-        target.end();
-    }
-}
-async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
-    throwIfCancelled(token);
-    const handle = await provider.open(resource, { create: false });
-    try {
-        throwIfCancelled(token);
-        let totalBytesRead = 0;
-        let bytesRead = 0;
-        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
-        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
-        let posInBuffer = 0;
-        do {
-            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
-            posInFile += bytesRead;
-            posInBuffer += bytesRead;
-            totalBytesRead += bytesRead;
-            if (typeof allowedRemainingBytes === 'number') {
-                allowedRemainingBytes -= bytesRead;
-            }
-            if (posInBuffer === buffer.byteLength) {
-                await target.write(transformer(buffer));
-                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
-                posInBuffer = 0;
-            }
-        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
-        if (posInBuffer > 0) {
-            let lastChunkLength = posInBuffer;
-            if (typeof allowedRemainingBytes === 'number') {
-                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
-            }
-            target.write(transformer(buffer.slice(0, lastChunkLength)));
-        }
-    }
-    catch (error) {
-        throw ensureFileSystemProviderError(error);
-    }
-    finally {
-        await provider.close(handle);
-    }
-}
-function throwIfCancelled(token) {
-    if (token.isCancellationRequested) {
-        throw canceled();
-    }
-    return true;
-}
-function throwIfTooLarge(totalBytesRead, options) {
-    if (options?.limits) {
-        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
-            throw createFileSystemProviderError(localize('fileTooLargeForHeapError', "To open a file of this size, you need to restart and allow to use more memory"), FileSystemProviderErrorCode.FileExceedsMemoryLimit);
-        }
-        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
-            throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
-        }
-    }
-    return true;
-}
-let FileService = class FileService extends Disposable {
-    constructor(logService) {
-        super();
-        this.logService = logService;
-        this.BUFFER_SIZE = 256 * 1024;
-        this._onDidChangeFileSystemProviderRegistrations = this._register(( (new Emitter())));
-        this.onDidChangeFileSystemProviderRegistrations = this._onDidChangeFileSystemProviderRegistrations.event;
-        this._onWillActivateFileSystemProvider = this._register(( (new Emitter())));
-        this.onWillActivateFileSystemProvider = this._onWillActivateFileSystemProvider.event;
-        this._onDidChangeFileSystemProviderCapabilities = this._register(( (new Emitter())));
-        this.onDidChangeFileSystemProviderCapabilities = this._onDidChangeFileSystemProviderCapabilities.event;
-        this.provider = ( (new Map()));
-        this._onDidRunOperation = this._register(( (new Emitter())));
-        this.onDidRunOperation = this._onDidRunOperation.event;
-        this._onDidFilesChange = this._register(( (new Emitter())));
-        this.onDidFilesChange = this._onDidFilesChange.event;
-        this._onDidWatchError = this._register(( (new Emitter())));
-        this.onDidWatchError = this._onDidWatchError.event;
-        this.activeWatchers = ( (new Map()));
-        this.writeQueue = this._register(( (new ResourceQueue())));
-    }
-    registerProvider(scheme, provider) {
-        if (this.provider.has(scheme)) {
-            throw new Error(`A filesystem provider for the scheme '${scheme}' is already registered.`);
-        }
-        mark(`code/registerFilesystem/${scheme}`);
-        const providerDisposables = ( (new DisposableStore()));
-        this.provider.set(scheme, provider);
-        this._onDidChangeFileSystemProviderRegistrations.fire({ added: true, scheme, provider });
-        providerDisposables.add(provider.onDidChangeFile(changes => this._onDidFilesChange.fire(( (new FileChangesEvent(changes, !this.isPathCaseSensitive(provider)))))));
-        if (typeof provider.onDidWatchError === 'function') {
-            providerDisposables.add(provider.onDidWatchError(error => this._onDidWatchError.fire(( (new Error(error))))));
-        }
-        providerDisposables.add(provider.onDidChangeCapabilities(() => this._onDidChangeFileSystemProviderCapabilities.fire({ provider, scheme })));
-        return toDisposable(() => {
-            this._onDidChangeFileSystemProviderRegistrations.fire({ added: false, scheme, provider });
-            this.provider.delete(scheme);
-            dispose(providerDisposables);
-        });
-    }
-    getProvider(scheme) {
-        return this.provider.get(scheme);
-    }
-    async activateProvider(scheme) {
-        const joiners = [];
-        this._onWillActivateFileSystemProvider.fire({
-            scheme,
-            join(promise) {
-                joiners.push(promise);
-            },
-        });
-        if (this.provider.has(scheme)) {
-            return;
-        }
-        await Promises.settled(joiners);
-    }
-    async canHandleResource(resource) {
-        await this.activateProvider(resource.scheme);
-        return this.hasProvider(resource);
-    }
-    hasProvider(resource) {
-        return this.provider.has(resource.scheme);
-    }
-    hasCapability(resource, capability) {
-        const provider = this.provider.get(resource.scheme);
-        return !!(provider && (provider.capabilities & capability));
-    }
-    listCapabilities() {
-        return (
-             (Iterable.map(
-                this.provider,
-                ([scheme, provider]) => ({ scheme, capabilities: provider.capabilities })
-            ))
-        );
-    }
-    async withProvider(resource) {
-        if (!isAbsolutePath(resource)) {
-            throw new FileOperationError(localize('invalidPath', "Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 );
-        }
-        await this.activateProvider(resource.scheme);
-        const provider = this.provider.get(resource.scheme);
-        if (!provider) {
-            const error = ( (new ErrorNoTelemetry()));
-            error.message = ( (localize(
-                'noProviderFound',
-                "ENOPRO: No file system provider found for resource '{0}'",
-                 (resource.toString())
-            )));
-            throw error;
-        }
-        return provider;
-    }
-    async withReadProvider(resource) {
-        const provider = await this.withProvider(resource);
-        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider)) {
-            return provider;
-        }
-        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`);
-    }
-    async withWriteProvider(resource) {
-        const provider = await this.withProvider(resource);
-        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider)) {
-            return provider;
-        }
-        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite nor FileOpenReadWriteClose capability which is needed for the write operation.`);
-    }
-    async resolve(resource, options) {
-        try {
-            return await this.doResolveFile(resource, options);
-        }
-        catch (error) {
-            if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
-                throw new FileOperationError(localize('fileNotFoundError', "Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 );
-            }
-            throw ensureFileSystemProviderError(error);
-        }
-    }
-    async doResolveFile(resource, options) {
-        const provider = await this.withProvider(resource);
-        const isPathCaseSensitive = this.isPathCaseSensitive(provider);
-        const resolveTo = options?.resolveTo;
-        const resolveSingleChildDescendants = options?.resolveSingleChildDescendants;
-        const resolveMetadata = options?.resolveMetadata;
-        const stat = await provider.stat(resource);
-        let trie;
-        return this.toFileStat(provider, resource, stat, undefined, !!resolveMetadata, (stat, siblings) => {
-            if (!trie) {
-                trie = TernarySearchTree.forUris(() => !isPathCaseSensitive);
-                trie.set(resource, true);
-                if (resolveTo) {
-                    trie.fill(true, resolveTo);
-                }
-            }
-            if (trie.get(stat.resource) || trie.findSuperstr(stat.resource.with({ query: null, fragment: null } ))) {
-                return true;
-            }
-            if (stat.isDirectory && resolveSingleChildDescendants) {
-                return siblings === 1;
-            }
-            return false;
-        });
-    }
-    async toFileStat(provider, resource, stat, siblings, resolveMetadata, recurse) {
-        const { providerExtUri } = this.getExtUri(provider);
-        const fileStat = {
-            resource,
-            name: providerExtUri.basename(resource),
-            isFile: (stat.type & FileType.File) !== 0,
-            isDirectory: (stat.type & FileType.Directory) !== 0,
-            isSymbolicLink: (stat.type & FileType.SymbolicLink) !== 0,
-            mtime: stat.mtime,
-            ctime: stat.ctime,
-            size: stat.size,
-            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & 2048 ),
-            etag: etag({ mtime: stat.mtime, size: stat.size }),
-            children: undefined
-        };
-        if (fileStat.isDirectory && recurse(fileStat, siblings)) {
-            try {
-                const entries = await provider.readdir(resource);
-                const resolvedEntries = await Promises.settled(( (entries.map(async ([name, type]) => {
-                    try {
-                        const childResource = providerExtUri.joinPath(resource, name);
-                        const childStat = resolveMetadata ? await provider.stat(childResource) : { type };
-                        return await this.toFileStat(provider, childResource, childStat, entries.length, resolveMetadata, recurse);
-                    }
-                    catch (error) {
-                        this.logService.trace(error);
-                        return null;
-                    }
-                }))));
-                fileStat.children = coalesce(resolvedEntries);
-            }
-            catch (error) {
-                this.logService.trace(error);
-                fileStat.children = [];
-            }
-            return fileStat;
-        }
-        return fileStat;
-    }
-    async resolveAll(toResolve) {
-        return Promises.settled(( (toResolve.map(async (entry) => {
-            try {
-                return { stat: await this.doResolveFile(entry.resource, entry.options), success: true };
-            }
-            catch (error) {
-                this.logService.trace(error);
-                return { stat: undefined, success: false };
-            }
-        }))));
-    }
-    async stat(resource) {
-        const provider = await this.withProvider(resource);
-        const stat = await provider.stat(resource);
-        return this.toFileStat(provider, resource, stat, undefined, true, () => false );
-    }
-    async exists(resource) {
-        const provider = await this.withProvider(resource);
-        try {
-            const stat = await provider.stat(resource);
-            return !!stat;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    async canCreateFile(resource, options) {
-        try {
-            await this.doValidateCreateFile(resource, options);
-        }
-        catch (error) {
-            return error;
-        }
-        return true;
-    }
-    async doValidateCreateFile(resource, options) {
-        if (!options?.overwrite && (await this.exists(resource))) {
-            throw new FileOperationError(localize('fileExists', "Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 , options);
-        }
-    }
-    async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), options) {
-        await this.doValidateCreateFile(resource, options);
-        const fileStat = await this.writeFile(resource, bufferOrReadableOrStream);
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 0 , fileStat))));
-        return fileStat;
-    }
-    async writeFile(resource, bufferOrReadableOrStream, options) {
-        const provider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(resource), resource);
-        const { providerExtUri } = this.getExtUri(provider);
-        try {
-            const stat = await this.validateWriteFile(provider, resource, options);
-            if (!stat) {
-                await this.mkdirp(provider, providerExtUri.dirname(resource));
-            }
-            let bufferOrReadableOrStreamOrBufferedStream;
-            if (hasReadWriteCapability(provider) && !(bufferOrReadableOrStream instanceof VSBuffer)) {
-                if (isReadableStream(bufferOrReadableOrStream)) {
-                    const bufferedStream = await peekStream(bufferOrReadableOrStream, 3);
-                    if (bufferedStream.ended) {
-                        bufferOrReadableOrStreamOrBufferedStream = VSBuffer.concat(bufferedStream.buffer);
-                    }
-                    else {
-                        bufferOrReadableOrStreamOrBufferedStream = bufferedStream;
-                    }
-                }
-                else {
-                    bufferOrReadableOrStreamOrBufferedStream = peekReadable(bufferOrReadableOrStream, data => VSBuffer.concat(data), 3);
-                }
-            }
-            else {
-                bufferOrReadableOrStreamOrBufferedStream = bufferOrReadableOrStream;
-            }
-            if (!hasOpenReadWriteCloseCapability(provider) || (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer)) {
-                await this.doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream);
-            }
-            else {
-                await this.doWriteBuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
-            }
-            this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 4 ))));
-        }
-        catch (error) {
-            throw new FileOperationError(localize('err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), options);
-        }
-        return this.resolve(resource, { resolveMetadata: true });
-    }
-    async validateWriteFile(provider, resource, options) {
-        const unlock = !!options?.unlock;
-        if (unlock && !((provider.capabilities & 8192) )) {
-            throw new Error(localize('writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
-        }
-        let stat = undefined;
-        try {
-            stat = await provider.stat(resource);
-        }
-        catch (error) {
-            return undefined;
-        }
-        if ((stat.type & FileType.Directory) !== 0) {
-            throw new FileOperationError(localize('fileIsDirectoryWriteError', "Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
-        }
-        this.throwIfFileIsReadonly(resource, stat);
-        if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
-            typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
-            options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(localize('fileModifiedError', "File Modified Since"), 3 , options);
-        }
-        return stat;
-    }
-    async readFile(resource, options, token) {
-        const provider = await this.withReadProvider(resource);
-        if (options?.atomic) {
-            return this.doReadFileAtomic(provider, resource, options, token);
-        }
-        return this.doReadFile(provider, resource, options, token);
-    }
-    async doReadFileAtomic(provider, resource, options, token) {
-        return (
-             (new Promise((resolve, reject) => {
-                this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
-                    try {
-                        const content = await this.doReadFile(provider, resource, options, token);
-                        resolve(content);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                });
-            }))
-        );
-    }
-    async doReadFile(provider, resource, options, token) {
-        const stream = await this.doReadFileStream(provider, resource, {
-            ...options,
-            preferUnbuffered: true
-        }, token);
-        return {
-            ...stream,
-            value: await streamToBuffer(stream.value)
-        };
-    }
-    async readFileStream(resource, options, token) {
-        const provider = await this.withReadProvider(resource);
-        return this.doReadFileStream(provider, resource, options, token);
-    }
-    async doReadFileStream(provider, resource, options, token) {
-        const cancellableSource = ( (new CancellationTokenSource(token)));
-        const statPromise = this.validateReadFile(resource, options).then(stat => stat, error => {
-            cancellableSource.cancel();
-            throw error;
-        });
-        let fileStream = undefined;
-        try {
-            if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED) {
-                await statPromise;
-            }
-            if ((options?.atomic && hasFileAtomicReadCapability(provider)) ||
-                !(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) ||
-                (hasReadWriteCapability(provider) && options?.preferUnbuffered)
-            ) {
-                fileStream = this.readFileUnbuffered(provider, resource, options);
-            }
-            else if (hasFileReadStreamCapability(provider)) {
-                fileStream = this.readFileStreamed(provider, resource, cancellableSource.token, options);
-            }
-            else {
-                fileStream = this.readFileBuffered(provider, resource, cancellableSource.token, options);
-            }
-            const fileStat = await statPromise;
-            return {
-                ...fileStat,
-                value: fileStream
-            };
-        }
-        catch (error) {
-            if (fileStream) {
-                await consumeStream(fileStream);
-            }
-            throw this.restoreReadError(error, resource, options);
-        }
-    }
-    restoreReadError(error, resource, options) {
-        const message = ( (localize(
-            'err.read',
-            "Unable to read file '{0}' ({1})",
-            this.resourceForError(resource),
-             (ensureFileSystemProviderError(error).toString())
-        )));
-        if (error instanceof NotModifiedSinceFileOperationError) {
-            return (
-                 (new NotModifiedSinceFileOperationError(message, error.stat, options))
-            );
-        }
-        if (error instanceof TooLargeFileOperationError) {
-            return (
-                 (new TooLargeFileOperationError(message, error.fileOperationResult, error.size, error.options))
-            );
-        }
-        return (
-             (new FileOperationError(message, toFileOperationResult(error), options))
-        );
-    }
-    readFileStreamed(provider, resource, token, options = Object.create(null)) {
-        const fileStream = provider.readFileStream(resource, options, token);
-        return transform(fileStream, {
-            data: data => data instanceof VSBuffer ? data : VSBuffer.wrap(data),
-            error: error => this.restoreReadError(error, resource, options)
-        }, data => VSBuffer.concat(data));
-    }
-    readFileBuffered(provider, resource, token, options = Object.create(null)) {
-        const stream = newWriteableBufferStream();
-        readFileIntoStream(provider, resource, stream, data => data, {
-            ...options,
-            bufferSize: this.BUFFER_SIZE,
-            errorTransformer: error => this.restoreReadError(error, resource, options)
-        }, token);
-        return stream;
-    }
-    readFileUnbuffered(provider, resource, options) {
-        const stream = newWriteableStream(data => VSBuffer.concat(data));
-        (async () => {
-            try {
-                let buffer;
-                if (options?.atomic && hasFileAtomicReadCapability(provider)) {
-                    buffer = await provider.readFile(resource, { atomic: true });
-                }
-                else {
-                    buffer = await provider.readFile(resource);
-                }
-                if (typeof options?.position === 'number') {
-                    buffer = buffer.slice(options.position);
-                }
-                if (typeof options?.length === 'number') {
-                    buffer = buffer.slice(0, options.length);
-                }
-                this.validateReadFileLimits(resource, buffer.byteLength, options);
-                stream.end(VSBuffer.wrap(buffer));
-            }
-            catch (err) {
-                stream.error(err);
-                stream.end();
-            }
-        })();
-        return stream;
-    }
-    async validateReadFile(resource, options) {
-        const stat = await this.resolve(resource, { resolveMetadata: true });
-        if (stat.isDirectory) {
-            throw new FileOperationError(localize('fileIsDirectoryReadError', "Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
-        }
-        if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw new NotModifiedSinceFileOperationError(localize('fileNotModifiedError', "File not modified since"), stat, options);
-        }
-        this.validateReadFileLimits(resource, stat.size, options);
-        return stat;
-    }
-    validateReadFileLimits(resource, size, options) {
-        if (options?.limits) {
-            let tooLargeErrorResult = undefined;
-            if (typeof options.limits.memory === 'number' && size > options.limits.memory) {
-                tooLargeErrorResult = 9 ;
-            }
-            if (typeof options.limits.size === 'number' && size > options.limits.size) {
-                tooLargeErrorResult = 7 ;
-            }
-            if (typeof tooLargeErrorResult === 'number') {
-                throw new TooLargeFileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult, size, options);
-            }
-        }
-    }
-    async canMove(source, target, overwrite) {
-        return this.doCanMoveCopy(source, target, 'move', overwrite);
-    }
-    async canCopy(source, target, overwrite) {
-        return this.doCanMoveCopy(source, target, 'copy', overwrite);
-    }
-    async doCanMoveCopy(source, target, mode, overwrite) {
-        if (( (source.toString())) !== ( (target.toString()))) {
-            try {
-                const sourceProvider = mode === 'move' ? this.throwIfFileSystemIsReadonly(await this.withWriteProvider(source), source) : await this.withReadProvider(source);
-                const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
-                await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
-            }
-            catch (error) {
-                return error;
-            }
-        }
-        return true;
-    }
-    async move(source, target, overwrite) {
-        const sourceProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(source), source);
-        const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
-        const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'move', !!overwrite);
-        const fileStat = await this.resolve(target, { resolveMetadata: true });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(
-            source,
-            mode === 'move' ? 2  : 3 ,
-            fileStat
-        ))));
-        return fileStat;
-    }
-    async copy(source, target, overwrite) {
-        const sourceProvider = await this.withReadProvider(source);
-        const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
-        const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'copy', !!overwrite);
-        const fileStat = await this.resolve(target, { resolveMetadata: true });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(
-            source,
-            mode === 'copy' ? 3  : 2 ,
-            fileStat
-        ))));
-        return fileStat;
-    }
-    async doMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
-        if (( (source.toString())) === ( (target.toString()))) {
-            return mode;
-        }
-        const { exists, isSameResourceWithDifferentPathCase } = await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
-        if (exists && !isSameResourceWithDifferentPathCase && overwrite) {
-            await this.del(target, { recursive: true });
-        }
-        await this.mkdirp(targetProvider, this.getExtUri(targetProvider).providerExtUri.dirname(target));
-        if (mode === 'copy') {
-            if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
-                await sourceProvider.copy(source, target, { overwrite });
-            }
-            else {
-                const sourceFile = await this.resolve(source);
-                if (sourceFile.isDirectory) {
-                    await this.doCopyFolder(sourceProvider, sourceFile, targetProvider, target);
-                }
-                else {
-                    await this.doCopyFile(sourceProvider, source, targetProvider, target);
-                }
-            }
-            return mode;
-        }
-        else {
-            if (sourceProvider === targetProvider) {
-                await sourceProvider.rename(source, target, { overwrite });
-                return mode;
-            }
-            else {
-                await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'copy', overwrite);
-                await this.del(source, { recursive: true });
-                return 'copy';
-            }
-        }
-    }
-    async doCopyFile(sourceProvider, source, targetProvider, target) {
-        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
-            return this.doPipeBuffered(sourceProvider, source, targetProvider, target);
-        }
-        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
-            return this.doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target);
-        }
-        if (hasReadWriteCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
-            return this.doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target);
-        }
-        if (hasReadWriteCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
-            return this.doPipeUnbuffered(sourceProvider, source, targetProvider, target);
-        }
-    }
-    async doCopyFolder(sourceProvider, sourceFolder, targetProvider, targetFolder) {
-        await targetProvider.mkdir(targetFolder);
-        if (Array.isArray(sourceFolder.children)) {
-            await Promises.settled(( (sourceFolder.children.map(async (sourceChild) => {
-                const targetChild = this.getExtUri(targetProvider).providerExtUri.joinPath(targetFolder, sourceChild.name);
-                if (sourceChild.isDirectory) {
-                    return this.doCopyFolder(sourceProvider, await this.resolve(sourceChild.resource), targetProvider, targetChild);
-                }
-                else {
-                    return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
-                }
-            }))));
-        }
-    }
-    async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
-        let isSameResourceWithDifferentPathCase = false;
-        if (sourceProvider === targetProvider) {
-            const { providerExtUri, isPathCaseSensitive } = this.getExtUri(sourceProvider);
-            if (!isPathCaseSensitive) {
-                isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
-            }
-            if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw new Error(localize('unableToMoveCopyError1', "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system", this.resourceForError(source), this.resourceForError(target)));
-            }
-            if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
-                throw new Error(localize('unableToMoveCopyError2', "Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
-            }
-        }
-        const exists = await this.exists(target);
-        if (exists && !isSameResourceWithDifferentPathCase) {
-            if (!overwrite) {
-                throw new FileOperationError(localize('unableToMoveCopyError3', "Unable to move/copy '{0}' because target '{1}' already exists at destination.", this.resourceForError(source), this.resourceForError(target)), 4 );
-            }
-            if (sourceProvider === targetProvider) {
-                const { providerExtUri } = this.getExtUri(sourceProvider);
-                if (providerExtUri.isEqualOrParent(source, target)) {
-                    throw new Error(localize('unableToMoveCopyError4', "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
-                }
-            }
-        }
-        return { exists, isSameResourceWithDifferentPathCase };
-    }
-    getExtUri(provider) {
-        const isPathCaseSensitive = this.isPathCaseSensitive(provider);
-        return {
-            providerExtUri: isPathCaseSensitive ? extUri : extUriIgnorePathCase,
-            isPathCaseSensitive
-        };
-    }
-    isPathCaseSensitive(provider) {
-        return !!((provider.capabilities & 1024) );
-    }
-    async createFolder(resource) {
-        const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
-        await this.mkdirp(provider, resource);
-        const fileStat = await this.resolve(resource, { resolveMetadata: true });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 0 , fileStat))));
-        return fileStat;
-    }
-    async mkdirp(provider, directory) {
-        const directoriesToCreate = [];
-        const { providerExtUri } = this.getExtUri(provider);
-        while (!providerExtUri.isEqual(directory, providerExtUri.dirname(directory))) {
-            try {
-                const stat = await provider.stat(directory);
-                if ((stat.type & FileType.Directory) === 0) {
-                    throw new Error(localize('mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
-                }
-                break;
-            }
-            catch (error) {
-                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
-                    throw error;
-                }
-                directoriesToCreate.push(providerExtUri.basename(directory));
-                directory = providerExtUri.dirname(directory);
-            }
-        }
-        for (let i = directoriesToCreate.length - 1; i >= 0; i--) {
-            directory = providerExtUri.joinPath(directory, directoriesToCreate[i]);
-            try {
-                await provider.mkdir(directory);
-            }
-            catch (error) {
-                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
-                    throw error;
-                }
-            }
-        }
-    }
-    async canDelete(resource, options) {
-        try {
-            await this.doValidateDelete(resource, options);
-        }
-        catch (error) {
-            return error;
-        }
-        return true;
-    }
-    async doValidateDelete(resource, options) {
-        const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
-        const useTrash = !!options?.useTrash;
-        if (useTrash && !((provider.capabilities & 4096) )) {
-            throw new Error(localize('deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
-        }
-        let stat = undefined;
-        try {
-            stat = await provider.stat(resource);
-        }
-        catch (error) {
-        }
-        if (stat) {
-            this.throwIfFileIsReadonly(resource, stat);
-        }
-        else {
-            throw new FileOperationError(localize('deleteFailedNotFound', "Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 );
-        }
-        const recursive = !!options?.recursive;
-        if (!recursive) {
-            const stat = await this.resolve(resource);
-            if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
-                throw new Error(localize('deleteFailedNonEmptyFolder', "Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
-            }
-        }
-        return provider;
-    }
-    async del(resource, options) {
-        const provider = await this.doValidateDelete(resource, options);
-        const useTrash = !!options?.useTrash;
-        const recursive = !!options?.recursive;
-        await provider.delete(resource, { recursive, useTrash });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 1 ))));
-    }
-    async cloneFile(source, target) {
-        const sourceProvider = await this.withProvider(source);
-        const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
-        if (sourceProvider === targetProvider && this.getExtUri(sourceProvider).providerExtUri.isEqual(source, target)) {
-            return;
-        }
-        if (sourceProvider === targetProvider && hasFileCloneCapability(sourceProvider)) {
-            return sourceProvider.cloneFile(source, target);
-        }
-        await this.mkdirp(targetProvider, this.getExtUri(targetProvider).providerExtUri.dirname(target));
-        const sourceWriteQueue = this.writeQueue.queueFor(source, this.getExtUri(sourceProvider).providerExtUri);
-        if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
-            return sourceWriteQueue.queue(() => sourceProvider.copy(source, target, { overwrite: true }));
-        }
-        return sourceWriteQueue.queue(() => this.doCopyFile(sourceProvider, source, targetProvider, target));
-    }
-    watch(resource, options = { recursive: false, excludes: [] }) {
-        const disposables = ( (new DisposableStore()));
-        let watchDisposed = false;
-        let disposeWatch = () => { watchDisposed = true; };
-        disposables.add(toDisposable(() => disposeWatch()));
-        (async () => {
-            try {
-                const disposable = await this.doWatch(resource, options);
-                if (watchDisposed) {
-                    dispose(disposable);
-                }
-                else {
-                    disposeWatch = () => dispose(disposable);
-                }
-            }
-            catch (error) {
-                this.logService.error(error);
-            }
-        })();
-        return disposables;
-    }
-    async doWatch(resource, options) {
-        const provider = await this.withProvider(resource);
-        const watchHash = hash([this.getExtUri(provider).providerExtUri.getComparisonKey(resource), options]);
-        let watcher = this.activeWatchers.get(watchHash);
-        if (!watcher) {
-            watcher = {
-                count: 0,
-                disposable: provider.watch(resource, options)
-            };
-            this.activeWatchers.set(watchHash, watcher);
-        }
-        watcher.count += 1;
-        return toDisposable(() => {
-            if (watcher) {
-                watcher.count--;
-                if (watcher.count === 0) {
-                    dispose(watcher.disposable);
-                    this.activeWatchers.delete(watchHash);
-                }
-            }
-        });
-    }
-    dispose() {
-        super.dispose();
-        for (const [, watcher] of this.activeWatchers) {
-            dispose(watcher.disposable);
-        }
-        this.activeWatchers.clear();
-    }
-    async doWriteBuffered(provider, resource, options, readableOrStreamOrBufferedStream) {
-        return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
-            const handle = await provider.open(resource, { create: true, unlock: options?.unlock ?? false });
-            try {
-                if (isReadableStream(readableOrStreamOrBufferedStream) || isReadableBufferedStream(readableOrStreamOrBufferedStream)) {
-                    await this.doWriteStreamBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
-                }
-                else {
-                    await this.doWriteReadableBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
-                }
-            }
-            catch (error) {
-                throw ensureFileSystemProviderError(error);
-            }
-            finally {
-                await provider.close(handle);
-            }
-        });
-    }
-    async doWriteStreamBufferedQueued(provider, handle, streamOrBufferedStream) {
-        let posInFile = 0;
-        let stream;
-        if (isReadableBufferedStream(streamOrBufferedStream)) {
-            if (streamOrBufferedStream.buffer.length > 0) {
-                const chunk = VSBuffer.concat(streamOrBufferedStream.buffer);
-                await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
-                posInFile += chunk.byteLength;
-            }
-            if (streamOrBufferedStream.ended) {
-                return;
-            }
-            stream = streamOrBufferedStream.stream;
-        }
-        else {
-            stream = streamOrBufferedStream;
-        }
-        return (
-             (new Promise((resolve, reject) => {
-                listenStream(stream, {
-                    onData: async (chunk) => {
-                        stream.pause();
-                        try {
-                            await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
-                        }
-                        catch (error) {
-                            return reject(error);
-                        }
-                        posInFile += chunk.byteLength;
-                        setTimeout(() => stream.resume());
-                    },
-                    onError: error => reject(error),
-                    onEnd: () => resolve()
-                });
-            }))
-        );
-    }
-    async doWriteReadableBufferedQueued(provider, handle, readable) {
-        let posInFile = 0;
-        let chunk;
-        while ((chunk = readable.read()) !== null) {
-            await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
-            posInFile += chunk.byteLength;
-        }
-    }
-    async doWriteBuffer(provider, handle, buffer, length, posInFile, posInBuffer) {
-        let totalBytesWritten = 0;
-        while (totalBytesWritten < length) {
-            const bytesWritten = await provider.write(handle, posInFile + totalBytesWritten, buffer.buffer, posInBuffer + totalBytesWritten, length - totalBytesWritten);
-            totalBytesWritten += bytesWritten;
-        }
-    }
-    async doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream) {
-        return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(() => this.doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream));
-    }
-    async doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream) {
-        let buffer;
-        if (bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) {
-            buffer = bufferOrReadableOrStreamOrBufferedStream;
-        }
-        else if (isReadableStream(bufferOrReadableOrStreamOrBufferedStream)) {
-            buffer = await streamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
-        }
-        else if (isReadableBufferedStream(bufferOrReadableOrStreamOrBufferedStream)) {
-            buffer = await bufferedStreamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
-        }
-        else {
-            buffer = readableToBuffer(bufferOrReadableOrStreamOrBufferedStream);
-        }
-        await provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true, unlock: options?.unlock ?? false });
-    }
-    async doPipeBuffered(sourceProvider, source, targetProvider, target) {
-        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeBufferedQueued(sourceProvider, source, targetProvider, target));
-    }
-    async doPipeBufferedQueued(sourceProvider, source, targetProvider, target) {
-        let sourceHandle = undefined;
-        let targetHandle = undefined;
-        try {
-            sourceHandle = await sourceProvider.open(source, { create: false });
-            targetHandle = await targetProvider.open(target, { create: true, unlock: false });
-            const buffer = VSBuffer.alloc(this.BUFFER_SIZE);
-            let posInFile = 0;
-            let posInBuffer = 0;
-            let bytesRead = 0;
-            do {
-                bytesRead = await sourceProvider.read(sourceHandle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
-                await this.doWriteBuffer(targetProvider, targetHandle, buffer, bytesRead, posInFile, posInBuffer);
-                posInFile += bytesRead;
-                posInBuffer += bytesRead;
-                if (posInBuffer === buffer.byteLength) {
-                    posInBuffer = 0;
-                }
-            } while (bytesRead > 0);
-        }
-        catch (error) {
-            throw ensureFileSystemProviderError(error);
-        }
-        finally {
-            await Promises.settled([
-                typeof sourceHandle === 'number' ? sourceProvider.close(sourceHandle) : Promise.resolve(),
-                typeof targetHandle === 'number' ? targetProvider.close(targetHandle) : Promise.resolve(),
-            ]);
-        }
-    }
-    async doPipeUnbuffered(sourceProvider, source, targetProvider, target) {
-        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target));
-    }
-    async doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target) {
-        return targetProvider.writeFile(target, await sourceProvider.readFile(source), { create: true, overwrite: true, unlock: false });
-    }
-    async doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target) {
-        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target));
-    }
-    async doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target) {
-        const targetHandle = await targetProvider.open(target, { create: true, unlock: false });
-        try {
-            const buffer = await sourceProvider.readFile(source);
-            await this.doWriteBuffer(targetProvider, targetHandle, VSBuffer.wrap(buffer), buffer.byteLength, 0, 0);
-        }
-        catch (error) {
-            throw ensureFileSystemProviderError(error);
-        }
-        finally {
-            await targetProvider.close(targetHandle);
-        }
-    }
-    async doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target) {
-        const buffer = await streamToBuffer(this.readFileBuffered(sourceProvider, source, CancellationToken.None));
-        await this.doWriteUnbuffered(targetProvider, target, undefined, buffer);
-    }
-    throwIfFileSystemIsReadonly(provider, resource) {
-        if (provider.capabilities & 2048 ) {
-            throw new FileOperationError(localize('err.readonly', "Unable to modify readonly file '{0}'", this.resourceForError(resource)), 6 );
-        }
-        return provider;
-    }
-    throwIfFileIsReadonly(resource, stat) {
-        if ((stat.permissions ?? 0) & FilePermission.Readonly) {
-            throw new FileOperationError(localize('err.readonly', "Unable to modify readonly file '{0}'", this.resourceForError(resource)), 6 );
-        }
-    }
-    resourceForError(resource) {
-        if (resource.scheme === Schemas.file) {
-            return resource.fsPath;
-        }
-        return (
-             (resource.toString(true))
-        );
-    }
-};
-FileService = ( (__decorate([
-    ( (__param(0, ILogService)))
-], FileService)));
-let File$1 = 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._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);
-    }
-    async writeFile(resource, content, opts) {
-        const basename$1 = basename(resource);
-        const parent = this._lookupParentDirectory(resource);
-        let entry = parent.entries.get(basename$1);
-        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$1(basename$1)));
-            parent.entries.set(basename$1, entry);
-            this._fireSoon({ type: 1 , resource });
-        }
-        entry.mtime = Date.now();
-        entry.size = content.byteLength;
-        entry.data = content;
-        this._fireSoon({ type: 0 , resource });
-    }
-    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 = 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$1 = dirname(resource);
-        const basename$1 = basename(resource);
-        const parent = this._lookupAsDirectory(dirname$1, false);
-        if (parent.entries.has(basename$1)) {
-            parent.entries.delete(basename$1);
-            parent.mtime = Date.now();
-            parent.size -= 1;
-            this._fireSoon({ type: 0 , resource: dirname$1 }, { resource, type: 2  });
-        }
-    }
-    async mkdir(resource) {
-        if (this._lookup(resource, true)) {
-            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-        }
-        const basename$1 = basename(resource);
-        const dirname$1 = dirname(resource);
-        const parent = this._lookupAsDirectory(dirname$1, false);
-        const entry = ( (new Directory(basename$1)));
-        parent.entries.set(entry.name, entry);
-        parent.mtime = Date.now();
-        parent.size += 1;
-        this._fireSoon({ type: 0 , resource: dirname$1 }, { 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$1) {
-            return entry;
-        }
-        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
-    }
-    _lookupParentDirectory(uri) {
-        const dirname$1 = dirname(uri);
-        return this._lookupAsDirectory(dirname$1, 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);
-    }
-}
-let BinaryEditorModel = class BinaryEditorModel extends EditorModel {
-    constructor(resource, name, fileService) {
-        super();
-        this.resource = resource;
-        this.name = name;
-        this.fileService = fileService;
-        this.mime = Mimes.binary;
-    }
-    getName() {
-        return this.name;
-    }
-    getSize() {
-        return this.size;
-    }
-    getMime() {
-        return this.mime;
-    }
-    getETag() {
-        return this.etag;
-    }
-    async resolve() {
-        if (this.fileService.hasProvider(this.resource)) {
-            const stat = await this.fileService.stat(this.resource);
-            this.etag = stat.etag;
-            if (typeof stat.size === 'number') {
-                this.size = stat.size;
-            }
-        }
-        return super.resolve();
-    }
-};
-BinaryEditorModel = ( (__decorate([
-    ( (__param(2, IFileService)))
-], BinaryEditorModel)));
-let FileEditorInput = class FileEditorInput extends AbstractTextResourceEditorInput {
-    get typeId() {
-        return FILE_EDITOR_INPUT_ID;
-    }
-    get editorId() {
-        return DEFAULT_EDITOR_ASSOCIATION.id;
-    }
-    get capabilities() {
-        let capabilities = 32 ;
-        if (this.model) {
-            if (this.model.isReadonly()) {
-                capabilities |= 2 ;
-            }
-        }
-        else {
-            if (this.fileService.hasProvider(this.resource)) {
-                if (this.fileService.hasCapability(this.resource, 2048 )) {
-                    capabilities |= 2 ;
-                }
-            }
-            else {
-                capabilities |= 4 ;
-            }
-        }
-        if (!((capabilities & 2) )) {
-            capabilities |= 128 ;
-        }
-        return capabilities;
-    }
-    constructor(resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService, textFileService, textModelResolverService, labelService, fileService, filesConfigurationService, editorService, pathService, textResourceConfigurationService) {
-        super(resource, preferredResource, editorService, textFileService, labelService, fileService);
-        this.instantiationService = instantiationService;
-        this.textModelResolverService = textModelResolverService;
-        this.filesConfigurationService = filesConfigurationService;
-        this.pathService = pathService;
-        this.textResourceConfigurationService = textResourceConfigurationService;
-        this.forceOpenAs = 0 ;
-        this.model = undefined;
-        this.cachedTextFileModelReference = undefined;
-        this.modelListeners = this._register(( (new DisposableStore())));
-        this.model = this.textFileService.files.get(resource);
-        if (preferredName) {
-            this.setPreferredName(preferredName);
-        }
-        if (preferredDescription) {
-            this.setPreferredDescription(preferredDescription);
-        }
-        if (preferredEncoding) {
-            this.setPreferredEncoding(preferredEncoding);
-        }
-        if (preferredLanguageId) {
-            this.setPreferredLanguageId(preferredLanguageId);
-        }
-        if (typeof preferredContents === 'string') {
-            this.setPreferredContents(preferredContents);
-        }
-        this._register(this.textFileService.files.onDidCreate(model => this.onDidCreateTextFileModel(model)));
-        if (this.model) {
-            this.registerModelListeners(this.model);
-        }
-    }
-    onDidCreateTextFileModel(model) {
-        if (isEqual(model.resource, this.resource)) {
-            this.model = model;
-            this.registerModelListeners(model);
-        }
-    }
-    registerModelListeners(model) {
-        this.modelListeners.clear();
-        this.modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
-        this.modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
-        this.modelListeners.add(model.onDidSaveError(() => this._onDidChangeDirty.fire()));
-        this.modelListeners.add(Event.once(model.onWillDispose)(() => {
-            this.modelListeners.clear();
-            this.model = undefined;
-        }));
-    }
-    getName() {
-        return this.preferredName || super.getName();
-    }
-    setPreferredName(name) {
-        if (!this.allowLabelOverride()) {
-            return;
-        }
-        if (this.preferredName !== name) {
-            this.preferredName = name;
-            this._onDidChangeLabel.fire();
-        }
-    }
-    allowLabelOverride() {
-        return this.resource.scheme !== this.pathService.defaultUriScheme &&
-            this.resource.scheme !== Schemas.vscodeUserData &&
-            this.resource.scheme !== Schemas.file &&
-            this.resource.scheme !== Schemas.vscodeRemote;
-    }
-    getPreferredName() {
-        return this.preferredName;
-    }
-    getDescription(verbosity) {
-        return this.preferredDescription || super.getDescription(verbosity);
-    }
-    setPreferredDescription(description) {
-        if (!this.allowLabelOverride()) {
-            return;
-        }
-        if (this.preferredDescription !== description) {
-            this.preferredDescription = description;
-            this._onDidChangeLabel.fire();
-        }
-    }
-    getPreferredDescription() {
-        return this.preferredDescription;
-    }
-    getEncoding() {
-        if (this.model) {
-            return this.model.getEncoding();
-        }
-        return this.preferredEncoding;
-    }
-    getPreferredEncoding() {
-        return this.preferredEncoding;
-    }
-    async setEncoding(encoding, mode) {
-        this.setPreferredEncoding(encoding);
-        return this.model?.setEncoding(encoding, mode);
-    }
-    setPreferredEncoding(encoding) {
-        this.preferredEncoding = encoding;
-        this.setForceOpenAsText();
-    }
-    getLanguageId() {
-        if (this.model) {
-            return this.model.getLanguageId();
-        }
-        return this.preferredLanguageId;
-    }
-    getPreferredLanguageId() {
-        return this.preferredLanguageId;
-    }
-    setLanguageId(languageId, source) {
-        this.setPreferredLanguageId(languageId);
-        this.model?.setLanguageId(languageId, source);
-    }
-    setPreferredLanguageId(languageId) {
-        this.preferredLanguageId = languageId;
-        this.setForceOpenAsText();
-    }
-    setPreferredContents(contents) {
-        this.preferredContents = contents;
-        this.setForceOpenAsText();
-    }
-    setForceOpenAsText() {
-        this.forceOpenAs = 1 ;
-    }
-    setForceOpenAsBinary() {
-        this.forceOpenAs = 2 ;
-    }
-    isDirty() {
-        return !!(this.model?.isDirty());
-    }
-    isSaving() {
-        if (this.model?.hasState(0 ) || this.model?.hasState(3 ) || this.model?.hasState(5 )) {
-            return false;
-        }
-        if (this.filesConfigurationService.getAutoSaveMode() === 1 ) {
-            return true;
-        }
-        return super.isSaving();
-    }
-    prefersEditorPane(editorPanes) {
-        if (this.forceOpenAs === 2 ) {
-            return editorPanes.find(editorPane => editorPane.typeId === BINARY_FILE_EDITOR_ID);
-        }
-        return editorPanes.find(editorPane => editorPane.typeId === TEXT_FILE_EDITOR_ID);
-    }
-    resolve(options) {
-        if (this.forceOpenAs === 2 ) {
-            return this.doResolveAsBinary();
-        }
-        return this.doResolveAsText(options);
-    }
-    async doResolveAsText(options) {
-        try {
-            const preferredContents = this.preferredContents;
-            this.preferredContents = undefined;
-            await this.textFileService.files.resolve(this.resource, {
-                languageId: this.preferredLanguageId,
-                encoding: this.preferredEncoding,
-                contents: typeof preferredContents === 'string' ? createTextBufferFactory(preferredContents) : undefined,
-                reload: { async: true },
-                allowBinary: this.forceOpenAs === 1 ,
-                reason: 1 ,
-                limits: this.ensureLimits(options)
-            });
-            if (!this.cachedTextFileModelReference) {
-                this.cachedTextFileModelReference = await this.textModelResolverService.createModelReference(this.resource);
-            }
-            const model = this.cachedTextFileModelReference.object;
-            if (this.isDisposed()) {
-                this.disposeModelReference();
-            }
-            return model;
-        }
-        catch (error) {
-            if (error.textFileOperationResult === 0 ) {
-                return this.doResolveAsBinary();
-            }
-            throw error;
-        }
-    }
-    ensureLimits(options) {
-        if (options?.limits) {
-            return options.limits;
-        }
-        const defaultSizeLimit = getLargeFileConfirmationLimit(this.resource);
-        let configuredSizeLimit = undefined;
-        const configuredSizeLimitMb = this.textResourceConfigurationService.getValue(this.resource, 'workbench.editorLargeFileConfirmation');
-        if (typeof configuredSizeLimitMb === 'number') {
-            configuredSizeLimit = configuredSizeLimitMb * ByteSize.MB;
-        }
-        return {
-            size: Math.max(defaultSizeLimit, configuredSizeLimit ?? defaultSizeLimit)
-        };
-    }
-    async doResolveAsBinary() {
-        const model = this.instantiationService.createInstance(BinaryEditorModel, this.preferredResource, this.getName());
-        await model.resolve();
-        return model;
-    }
-    isResolved() {
-        return !!this.model;
-    }
-    async rename(group, target) {
-        return {
-            editor: {
-                resource: target,
-                encoding: this.getEncoding(),
-                options: {
-                    viewState: findViewStateForEditor(this, group, this.editorService)
-                }
-            }
-        };
-    }
-    toUntyped(options) {
-        const untypedInput = {
-            resource: this.preferredResource,
-            forceFile: true,
-            options: {
-                override: this.editorId
-            }
-        };
-        if (typeof options?.preserveViewState === 'number') {
-            untypedInput.encoding = this.getEncoding();
-            untypedInput.languageId = this.getLanguageId();
-            untypedInput.contents = (() => {
-                const model = this.textFileService.files.get(this.resource);
-                if (model?.isDirty()) {
-                    return model.textEditorModel.getValue();
-                }
-                return undefined;
-            })();
-            untypedInput.options = {
-                ...untypedInput.options,
-                viewState: findViewStateForEditor(this, options.preserveViewState, this.editorService)
-            };
-        }
-        return untypedInput;
-    }
-    matches(otherInput) {
-        if (this === otherInput) {
-            return true;
-        }
-        if (otherInput instanceof FileEditorInput) {
-            return isEqual(otherInput.resource, this.resource);
-        }
-        if (isResourceEditorInput(otherInput)) {
-            return super.matches(otherInput);
-        }
-        return false;
-    }
-    dispose() {
-        this.model = undefined;
-        this.disposeModelReference();
-        super.dispose();
-    }
-    disposeModelReference() {
-        dispose(this.cachedTextFileModelReference);
-        this.cachedTextFileModelReference = undefined;
-    }
-};
-FileEditorInput = ( (__decorate([
-    ( (__param(7, IInstantiationService))),
-    ( (__param(8, ITextFileService))),
-    ( (__param(9, ITextModelService))),
-    ( (__param(10, ILabelService))),
-    ( (__param(11, IFileService))),
-    ( (__param(12, IFilesConfigurationService))),
-    ( (__param(13, IEditorService))),
-    ( (__param(14, IPathService))),
-    ( (__param(15, ITextResourceConfigurationService)))
-], FileEditorInput)));
-class ExplorerFileNestingTrie {
-    constructor(config) {
-        this.root = ( (new PreTrie()));
-        for (const [parentPattern, childPatterns] of config) {
-            for (const childPattern of childPatterns) {
-                this.root.add(parentPattern, childPattern);
-            }
-        }
-    }
-    toString() {
-        return (
-             (this.root.toString())
-        );
-    }
-    getAttributes(filename, dirname) {
-        const lastDot = filename.lastIndexOf('.');
-        if (lastDot < 1) {
-            return {
-                dirname,
-                basename: filename,
-                extname: ''
-            };
-        }
-        else {
-            return {
-                dirname,
-                basename: filename.substring(0, lastDot),
-                extname: filename.substring(lastDot + 1)
-            };
-        }
-    }
-    nest(files, dirname) {
-        const parentFinder = ( (new PreTrie()));
-        for (const potentialParent of files) {
-            const attributes = this.getAttributes(potentialParent, dirname);
-            const children = this.root.get(potentialParent, attributes);
-            for (const child of children) {
-                parentFinder.add(child, potentialParent);
-            }
-        }
-        const findAllRootAncestors = (file, seen = ( (new Set()))) => {
-            if (seen.has(file)) {
-                return [];
-            }
-            seen.add(file);
-            const attributes = this.getAttributes(file, dirname);
-            const ancestors = parentFinder.get(file, attributes);
-            if (ancestors.length === 0) {
-                return [file];
-            }
-            if (ancestors.length === 1 && ancestors[0] === file) {
-                return [file];
-            }
-            return ancestors.flatMap(a => findAllRootAncestors(a, seen));
-        };
-        const result = ( (new Map()));
-        for (const file of files) {
-            let ancestors = findAllRootAncestors(file);
-            if (ancestors.length === 0) {
-                ancestors = [file];
-            }
-            for (const ancestor of ancestors) {
-                let existing = result.get(ancestor);
-                if (!existing) {
-                    result.set(ancestor, existing = ( (new Set())));
-                }
-                if (file !== ancestor) {
-                    existing.add(file);
-                }
-            }
-        }
-        return result;
-    }
-}
-class PreTrie {
-    constructor() {
-        this.value = ( (new SufTrie()));
-        this.map = ( (new Map()));
-    }
-    add(key, value) {
-        if (key === '') {
-            this.value.add(key, value);
-        }
-        else if (key[0] === '*') {
-            this.value.add(key, value);
-        }
-        else {
-            const head = key[0];
-            const rest = key.slice(1);
-            let existing = this.map.get(head);
-            if (!existing) {
-                this.map.set(head, existing = ( (new PreTrie())));
-            }
-            existing.add(rest, value);
-        }
-    }
-    get(key, attributes) {
-        const results = [];
-        results.push(...this.value.get(key, attributes));
-        const head = key[0];
-        const rest = key.slice(1);
-        const existing = this.map.get(head);
-        if (existing) {
-            results.push(...existing.get(rest, attributes));
-        }
-        return results;
-    }
-    toString(indentation = '') {
-        const lines = [];
-        if (this.value.hasItems) {
-            lines.push('* => \n' + ( (this.value.toString(indentation + '  '))));
-        }
-        return ( (lines.map(l => indentation + l))).join('\n');
-    }
-}
-class SufTrie {
-    constructor() {
-        this.star = [];
-        this.epsilon = [];
-        this.map = ( (new Map()));
-        this.hasItems = false;
-    }
-    add(key, value) {
-        this.hasItems = true;
-        if (key === '*') {
-            this.star.push(( (new SubstitutionString(value))));
-        }
-        else if (key === '') {
-            this.epsilon.push(( (new SubstitutionString(value))));
-        }
-        else {
-            const tail = key[key.length - 1];
-            const rest = key.slice(0, key.length - 1);
-            if (tail === '*') {
-                throw Error('Unexpected star in SufTrie key: ' + key);
-            }
-            else {
-                let existing = this.map.get(tail);
-                if (!existing) {
-                    this.map.set(tail, existing = ( (new SufTrie())));
-                }
-                existing.add(rest, value);
-            }
-        }
-    }
-    get(key, attributes) {
-        const results = [];
-        if (key === '') {
-            results.push(...( (this.epsilon.map(ss => ss.substitute(attributes)))));
-        }
-        if (this.star.length) {
-            results.push(...( (this.star.map(ss => ss.substitute(attributes, key)))));
-        }
-        const tail = key[key.length - 1];
-        const rest = key.slice(0, key.length - 1);
-        const existing = this.map.get(tail);
-        if (existing) {
-            results.push(...existing.get(rest, attributes));
-        }
-        return results;
-    }
-    toString(indentation = '') {
-        const lines = [];
-        if (this.star.length) {
-            lines.push('* => ' + this.star.join('; '));
-        }
-        if (this.epsilon.length) {
-            lines.push('ε => ' + this.epsilon.join('; '));
-        }
-        return ( (lines.map(l => indentation + l))).join('\n');
-    }
-}
-const substitutionStringTokenizer = /\$[({](capture|basename|dirname|extname)[)}]/g;
-class SubstitutionString {
-    constructor(pattern) {
-        this.tokens = [];
-        substitutionStringTokenizer.lastIndex = 0;
-        let token;
-        let lastIndex = 0;
-        while (token = substitutionStringTokenizer.exec(pattern)) {
-            const prefix = pattern.slice(lastIndex, token.index);
-            this.tokens.push(prefix);
-            const type = token[1];
-            switch (type) {
-                case "basename" :
-                case "dirname" :
-                case "extname" :
-                case "capture" :
-                    this.tokens.push({ capture: type });
-                    break;
-                default: throw Error('unknown substitution type: ' + type);
-            }
-            lastIndex = token.index + token[0].length;
-        }
-        if (lastIndex !== pattern.length) {
-            const suffix = pattern.slice(lastIndex, pattern.length);
-            this.tokens.push(suffix);
-        }
-    }
-    substitute(attributes, capture) {
-        return ( (this.tokens.map(t => {
-            if (typeof t === 'string') {
-                return t;
-            }
-            switch (t.capture) {
-                case "basename" : return attributes.basename;
-                case "dirname" : return attributes.dirname;
-                case "extname" : return attributes.extname;
-                case "capture" : return capture || '';
-            }
-        }))).join('');
-    }
-}
-class ExplorerModel {
-    constructor(contextService, uriIdentityService, fileService, configService) {
-        this.contextService = contextService;
-        this.uriIdentityService = uriIdentityService;
-        this._onDidChangeRoots = ( (new Emitter()));
-        const setRoots = () => this._roots = ( (this.contextService.getWorkspace().folders
-            .map(folder => ( (new ExplorerItem(
-            folder.uri,
-            fileService,
-            configService,
-            undefined,
-            true,
-            false,
-            false,
-            folder.name
-        ))))));
-        setRoots();
-        this._listener = this.contextService.onDidChangeWorkspaceFolders(() => {
-            setRoots();
-            this._onDidChangeRoots.fire();
-        });
-    }
-    get roots() {
-        return this._roots;
-    }
-    get onDidChangeRoots() {
-        return this._onDidChangeRoots.event;
-    }
-    findAll(resource) {
-        return coalesce(( (this.roots.map(root => root.find(resource)))));
-    }
-    findClosest(resource) {
-        const folder = this.contextService.getWorkspaceFolder(resource);
-        if (folder) {
-            const root = this.roots.find(r => this.uriIdentityService.extUri.isEqual(r.resource, folder.uri));
-            if (root) {
-                return root.find(resource);
-            }
-        }
-        return null;
-    }
-    dispose() {
-        dispose(this._listener);
-    }
-}
-class ExplorerItem {
-    constructor(resource, fileService, configService, _parent, _isDirectory, _isSymbolicLink, _readonly, _name = basenameOrAuthority(resource), _mtime, _unknown = false) {
-        this.resource = resource;
-        this.fileService = fileService;
-        this.configService = configService;
-        this._parent = _parent;
-        this._isDirectory = _isDirectory;
-        this._isSymbolicLink = _isSymbolicLink;
-        this._readonly = _readonly;
-        this._name = _name;
-        this._mtime = _mtime;
-        this._unknown = _unknown;
-        this.error = undefined;
-        this._isExcluded = false;
-        this._isDirectoryResolved = false;
-    }
-    get isExcluded() {
-        if (this._isExcluded) {
-            return true;
-        }
-        if (!this._parent) {
-            return false;
-        }
-        return this._parent.isExcluded;
-    }
-    set isExcluded(value) {
-        this._isExcluded = value;
-    }
-    hasChildren(filter) {
-        if (this.hasNests) {
-            return this.nestedChildren?.some(c => filter(c)) ?? false;
-        }
-        else {
-            return this.isDirectory;
-        }
-    }
-    get hasNests() {
-        return !!(this.nestedChildren?.length);
-    }
-    get isDirectoryResolved() {
-        return this._isDirectoryResolved;
-    }
-    get isSymbolicLink() {
-        return !!this._isSymbolicLink;
-    }
-    get isDirectory() {
-        return !!this._isDirectory;
-    }
-    get isReadonly() {
-        return this._readonly || this.fileService.hasCapability(this.resource, 2048 );
-    }
-    get mtime() {
-        return this._mtime;
-    }
-    get name() {
-        return this._name;
-    }
-    get isUnknown() {
-        return this._unknown;
-    }
-    get parent() {
-        return this._parent;
-    }
-    get root() {
-        if (!this._parent) {
-            return this;
-        }
-        return this._parent.root;
-    }
-    get children() {
-        return (
-             (new Map())
-        );
-    }
-    updateName(value) {
-        this._parent?.removeChild(this);
-        this._name = value;
-        this._parent?.addChild(this);
-    }
-    getId() {
-        return ( (this.root.resource.toString())) + '::' + ( (this.resource.toString()));
-    }
-    toString() {
-        return `ExplorerItem: ${this.name}`;
-    }
-    get isRoot() {
-        return this === this.root;
-    }
-    static create(fileService, configService, raw, parent, resolveTo) {
-        const stat = ( (new ExplorerItem(
-            raw.resource,
-            fileService,
-            configService,
-            parent,
-            raw.isDirectory,
-            raw.isSymbolicLink,
-            raw.readonly,
-            raw.name,
-            raw.mtime,
-            !raw.isFile && !raw.isDirectory
-        )));
-        if (stat.isDirectory) {
-            stat._isDirectoryResolved = !!raw.children || (!!resolveTo && resolveTo.some((r) => {
-                return isEqualOrParent(r, stat.resource);
-            }));
-            if (raw.children) {
-                for (let i = 0, len = raw.children.length; i < len; i++) {
-                    const child = ExplorerItem.create(fileService, configService, raw.children[i], stat, resolveTo);
-                    stat.addChild(child);
-                }
-            }
-        }
-        return stat;
-    }
-    static mergeLocalWithDisk(disk, local) {
-        if (( (disk.resource.toString())) !== ( (local.resource.toString()))) {
-            return;
-        }
-        const mergingDirectories = disk.isDirectory || local.isDirectory;
-        if (mergingDirectories && local._isDirectoryResolved && !disk._isDirectoryResolved) {
-            return;
-        }
-        local.resource = disk.resource;
-        if (!local.isRoot) {
-            local.updateName(disk.name);
-        }
-        local._isDirectory = disk.isDirectory;
-        local._mtime = disk.mtime;
-        local._isDirectoryResolved = disk._isDirectoryResolved;
-        local._isSymbolicLink = disk.isSymbolicLink;
-        local.error = disk.error;
-        if (mergingDirectories && disk._isDirectoryResolved) {
-            const oldLocalChildren = ( (new ResourceMap()));
-            local.children.forEach(child => {
-                oldLocalChildren.set(child.resource, child);
-            });
-            local.children.clear();
-            disk.children.forEach(diskChild => {
-                const formerLocalChild = oldLocalChildren.get(diskChild.resource);
-                if (formerLocalChild) {
-                    ExplorerItem.mergeLocalWithDisk(diskChild, formerLocalChild);
-                    local.addChild(formerLocalChild);
-                    oldLocalChildren.delete(diskChild.resource);
-                }
-                else {
-                    local.addChild(diskChild);
-                }
-            });
-            oldLocalChildren.forEach(oldChild => {
-                if (oldChild instanceof NewExplorerItem) {
-                    local.addChild(oldChild);
-                }
-            });
-        }
-    }
-    addChild(child) {
-        child._parent = this;
-        child.updateResource(false);
-        this.children.set(this.getPlatformAwareName(child.name), child);
-    }
-    getChild(name) {
-        return this.children.get(this.getPlatformAwareName(name));
-    }
-    fetchChildren(sortOrder) {
-        const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
-        if (nestingConfig.enabled && this.nestedChildren) {
-            return this.nestedChildren;
-        }
-        return (async () => {
-            if (!this._isDirectoryResolved) {
-                const resolveMetadata = sortOrder === "modified" ;
-                this.error = undefined;
-                try {
-                    const stat = await this.fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
-                    const resolved = ExplorerItem.create(this.fileService, this.configService, stat, this);
-                    ExplorerItem.mergeLocalWithDisk(resolved, this);
-                }
-                catch (e) {
-                    this.error = e;
-                    throw e;
-                }
-                this._isDirectoryResolved = true;
-            }
-            const items = [];
-            if (nestingConfig.enabled) {
-                const fileChildren = [];
-                const dirChildren = [];
-                for (const child of this.children.entries()) {
-                    child[1].nestedParent = undefined;
-                    if (child[1].isDirectory) {
-                        dirChildren.push(child);
-                    }
-                    else {
-                        fileChildren.push(child);
-                    }
-                }
-                const nested = this.fileNester.nest(( (fileChildren.map(([name]) => name))), this.getPlatformAwareName(this.name));
-                for (const [fileEntryName, fileEntryItem] of fileChildren) {
-                    const nestedItems = nested.get(fileEntryName);
-                    if (nestedItems !== undefined) {
-                        fileEntryItem.nestedChildren = [];
-                        for (const name of ( (nestedItems.keys()))) {
-                            const child = assertIsDefined(this.children.get(name));
-                            fileEntryItem.nestedChildren.push(child);
-                            child.nestedParent = fileEntryItem;
-                        }
-                        items.push(fileEntryItem);
-                    }
-                    else {
-                        fileEntryItem.nestedChildren = undefined;
-                    }
-                }
-                for (const [_, dirEntryItem] of ( (dirChildren.values()))) {
-                    items.push(dirEntryItem);
-                }
-            }
-            else {
-                this.children.forEach(child => {
-                    items.push(child);
-                });
-            }
-            return items;
-        })();
-    }
-    get fileNester() {
-        if (!this.root._fileNester) {
-            const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
-            const patterns = ( (Object.entries(nestingConfig.patterns)
-                .filter(entry => typeof (entry[0]) === 'string' && typeof (entry[1]) === 'string' && entry[0] && entry[1])
-                .map(([parentPattern, childrenPatterns]) => [
-                this.getPlatformAwareName(parentPattern.trim()),
-                ( (childrenPatterns.split(',').map(p => this.getPlatformAwareName(p.trim().replace(/\u200b/g, '')))))
-            ])));
-            this.root._fileNester = ( (new ExplorerFileNestingTrie(patterns)));
-        }
-        return this.root._fileNester;
-    }
-    removeChild(child) {
-        this.nestedChildren = undefined;
-        this.children.delete(this.getPlatformAwareName(child.name));
-    }
-    forgetChildren() {
-        this.children.clear();
-        this.nestedChildren = undefined;
-        this._isDirectoryResolved = false;
-        this._fileNester = undefined;
-    }
-    getPlatformAwareName(name) {
-        return this.fileService.hasCapability(this.resource, 1024 ) ? name : name.toLowerCase();
-    }
-    move(newParent) {
-        this.nestedParent?.removeChild(this);
-        this._parent?.removeChild(this);
-        newParent.removeChild(this);
-        newParent.addChild(this);
-        this.updateResource(true);
-    }
-    updateResource(recursive) {
-        if (this._parent) {
-            this.resource = joinPath(this._parent.resource, this.name);
-        }
-        if (recursive) {
-            if (this.isDirectory) {
-                this.children.forEach(child => {
-                    child.updateResource(true);
-                });
-            }
-        }
-    }
-    rename(renamedStat) {
-        this.updateName(renamedStat.name);
-        this._mtime = renamedStat.mtime;
-        this.updateResource(true);
-    }
-    find(resource) {
-        const ignoreCase = !this.fileService.hasCapability(resource, 1024 );
-        if (resource && this.resource.scheme === resource.scheme && equalsIgnoreCase(this.resource.authority, resource.authority) &&
-            (ignoreCase ? startsWithIgnoreCase(resource.path, this.resource.path) : resource.path.startsWith(this.resource.path))) {
-            return this.findByPath(rtrim(resource.path, posix.sep), this.resource.path.length, ignoreCase);
-        }
-        return null;
-    }
-    findByPath(path, index, ignoreCase) {
-        if (isEqual$1(rtrim(this.resource.path, posix.sep), path, ignoreCase)) {
-            return this;
-        }
-        if (this.isDirectory) {
-            while (index < path.length && path[index] === posix.sep) {
-                index++;
-            }
-            let indexOfNextSep = path.indexOf(posix.sep, index);
-            if (indexOfNextSep === -1) {
-                indexOfNextSep = path.length;
-            }
-            const name = path.substring(index, indexOfNextSep);
-            const child = this.children.get(this.getPlatformAwareName(name));
-            if (child) {
-                return child.findByPath(path, indexOfNextSep, ignoreCase);
-            }
-        }
-        return null;
-    }
-}
-ExplorerItem.__decorator = ( (__decorate([
-    memoize
-], ExplorerItem.prototype, "children", null)));
-class NewExplorerItem extends ExplorerItem {
-    constructor(fileService, configService, parent, isDirectory) {
-        super(URI.file(''), fileService, configService, parent, isDirectory);
-        this._isDirectoryResolved = true;
-    }
-}
-const IExplorerService = ( (createDecorator('explorerService')));
-let ResourceGlobMatcher = class ResourceGlobMatcher extends Disposable {
-    constructor(globFn, shouldUpdate, contextService, configurationService) {
-        super();
-        this.globFn = globFn;
-        this.shouldUpdate = shouldUpdate;
-        this.contextService = contextService;
-        this.configurationService = configurationService;
-        this._onExpressionChange = this._register(( (new Emitter())));
-        this.onExpressionChange = this._onExpressionChange.event;
-        this.mapRootToParsedExpression = ( (new Map()));
-        this.mapRootToExpressionConfig = ( (new Map()));
-        this.updateExcludes(false);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (this.shouldUpdate(e)) {
-                this.updateExcludes(true);
-            }
-        }));
-        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExcludes(true)));
-    }
-    updateExcludes(fromEvent) {
-        let changed = false;
-        this.contextService.getWorkspace().folders.forEach(folder => {
-            const rootExcludes = this.globFn(folder.uri);
-            if (!this.mapRootToExpressionConfig.has(( (folder.uri.toString()))) || !equals(this.mapRootToExpressionConfig.get(( (folder.uri.toString()))), rootExcludes)) {
-                changed = true;
-                this.mapRootToParsedExpression.set(( (folder.uri.toString())), parse(rootExcludes));
-                this.mapRootToExpressionConfig.set(( (folder.uri.toString())), deepClone(rootExcludes));
-            }
-        });
-        this.mapRootToExpressionConfig.forEach((value, root) => {
-            if (root === ResourceGlobMatcher.NO_ROOT) {
-                return;
-            }
-            if (root && !this.contextService.getWorkspaceFolder(( (URI.parse(root))))) {
-                this.mapRootToParsedExpression.delete(root);
-                this.mapRootToExpressionConfig.delete(root);
-                changed = true;
-            }
-        });
-        const globalExcludes = this.globFn();
-        if (!this.mapRootToExpressionConfig.has(ResourceGlobMatcher.NO_ROOT) || !equals(this.mapRootToExpressionConfig.get(ResourceGlobMatcher.NO_ROOT), globalExcludes)) {
-            changed = true;
-            this.mapRootToParsedExpression.set(ResourceGlobMatcher.NO_ROOT, parse(globalExcludes));
-            this.mapRootToExpressionConfig.set(ResourceGlobMatcher.NO_ROOT, deepClone(globalExcludes));
-        }
-        if (fromEvent && changed) {
-            this._onExpressionChange.fire();
-        }
-    }
-    matches(resource, hasSibling) {
-        const folder = this.contextService.getWorkspaceFolder(resource);
-        let expressionForRoot;
-        if (folder && this.mapRootToParsedExpression.has(( (folder.uri.toString())))) {
-            expressionForRoot = this.mapRootToParsedExpression.get(( (folder.uri.toString())));
-        }
-        else {
-            expressionForRoot = this.mapRootToParsedExpression.get(ResourceGlobMatcher.NO_ROOT);
-        }
-        let resourcePathToMatch;
-        if (folder) {
-            resourcePathToMatch = relativePath(folder.uri, resource);
-        }
-        else {
-            resourcePathToMatch = resource.fsPath;
-        }
-        return !!expressionForRoot && typeof resourcePathToMatch === 'string' && !!expressionForRoot(resourcePathToMatch, undefined, hasSibling);
-    }
-};
-ResourceGlobMatcher.NO_ROOT = null;
-ResourceGlobMatcher = ( (__decorate([
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IConfigurationService)))
-], ResourceGlobMatcher)));
-const UNDO_REDO_SOURCE = ( (new UndoRedoSource()));
-let ExplorerService = class ExplorerService {
-    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService) {
-        this.fileService = fileService;
-        this.configurationService = configurationService;
-        this.contextService = contextService;
-        this.clipboardService = clipboardService;
-        this.editorService = editorService;
-        this.uriIdentityService = uriIdentityService;
-        this.bulkEditService = bulkEditService;
-        this.progressService = progressService;
-        this.disposables = ( (new DisposableStore()));
-        this.fileChangeEvents = [];
-        this.config = this.configurationService.getValue('explorer');
-        this.model = ( (new ExplorerModel(
-            this.contextService,
-            this.uriIdentityService,
-            this.fileService,
-            this.configurationService
-        )));
-        this.disposables.add(this.model);
-        this.disposables.add(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
-        this.onFileChangesScheduler = ( (new RunOnceScheduler(async () => {
-            const events = this.fileChangeEvents;
-            this.fileChangeEvents = [];
-            const types = [2 ];
-            if (this.config.sortOrder === "modified" ) {
-                types.push(0 );
-            }
-            let shouldRefresh = false;
-            this.roots.forEach(r => {
-                if (this.view && !shouldRefresh) {
-                    shouldRefresh = doesFileEventAffect(r, this.view, events, types);
-                }
-            });
-            events.forEach(e => {
-                if (!shouldRefresh) {
-                    for (const resource of e.rawAdded) {
-                        const parent = this.model.findClosest(dirname(resource));
-                        if (parent && !parent.getChild(basename(resource))) {
-                            shouldRefresh = true;
-                            break;
-                        }
-                    }
-                }
-            });
-            if (shouldRefresh) {
-                await this.refresh(false);
-            }
-        }, ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY)));
-        this.disposables.add(this.fileService.onDidFilesChange(e => {
-            this.fileChangeEvents.push(e);
-            if (this.editable) {
-                return;
-            }
-            if (!this.onFileChangesScheduler.isScheduled()) {
-                this.onFileChangesScheduler.schedule();
-            }
-        }));
-        this.disposables.add(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
-        this.disposables.add(Event.any(this.fileService.onDidChangeFileSystemProviderRegistrations, this.fileService.onDidChangeFileSystemProviderCapabilities)(async (e) => {
-            let affected = false;
-            this.model.roots.forEach(r => {
-                if (r.resource.scheme === e.scheme) {
-                    affected = true;
-                    r.forgetChildren();
-                }
-            });
-            if (affected) {
-                if (this.view) {
-                    await this.view.setTreeInput();
-                }
-            }
-        }));
-        this.disposables.add(this.model.onDidChangeRoots(() => {
-            this.view?.setTreeInput();
-        }));
-        this.disposables.add(hostService.onDidChangeFocus(hasFocus => {
-            if (hasFocus) {
-                this.refresh(false);
-            }
-        }));
-        this.revealExcludeMatcher = ( (new ResourceGlobMatcher(
-            (uri) => getRevealExcludes(configurationService.getValue({ resource: uri })),
-            (event) => event.affectsConfiguration('explorer.autoRevealExclude'),
-            contextService,
-            configurationService
-        )));
-        this.disposables.add(this.revealExcludeMatcher);
-    }
-    get roots() {
-        return this.model.roots;
-    }
-    get sortOrderConfiguration() {
-        return {
-            sortOrder: this.config.sortOrder,
-            lexicographicOptions: this.config.sortOrderLexicographicOptions,
-        };
-    }
-    registerView(contextProvider) {
-        this.view = contextProvider;
-    }
-    getContext(respectMultiSelection, ignoreNestedChildren = false) {
-        if (!this.view) {
-            return [];
-        }
-        const items = ( (new Set(this.view.getContext(respectMultiSelection))));
-        items.forEach(item => {
-            try {
-                if (respectMultiSelection && !ignoreNestedChildren && this.view?.isItemCollapsed(item) && item.nestedChildren) {
-                    for (const child of item.nestedChildren) {
-                        items.add(child);
-                    }
-                }
-            }
-            catch {
-                return;
-            }
-        });
-        return [...items];
-    }
-    async applyBulkEdit(edit, options) {
-        const cancellationTokenSource = ( (new CancellationTokenSource()));
-        const promise = this.progressService.withProgress({
-            location: options.progressLocation || 10 ,
-            title: options.progressLabel,
-            cancellable: edit.length > 1,
-            delay: 500,
-        }, async (progress) => {
-            await this.bulkEditService.apply(edit, {
-                undoRedoSource: UNDO_REDO_SOURCE,
-                label: options.undoLabel,
-                code: 'undoredo.explorerOperation',
-                progress,
-                token: cancellationTokenSource.token,
-                confirmBeforeUndo: options.confirmBeforeUndo
-            });
-        }, () => cancellationTokenSource.cancel());
-        await this.progressService.withProgress({ location: 1 , delay: 500 }, () => promise);
-        cancellationTokenSource.dispose();
-    }
-    hasViewFocus() {
-        return !!this.view && this.view.hasFocus();
-    }
-    findClosest(resource) {
-        return this.model.findClosest(resource);
-    }
-    findClosestRoot(resource) {
-        const parentRoots = this.model.roots.filter(r => this.uriIdentityService.extUri.isEqualOrParent(resource, r.resource))
-            .sort((first, second) => second.resource.path.length - first.resource.path.length);
-        return parentRoots.length ? parentRoots[0] : null;
-    }
-    async setEditable(stat, data) {
-        if (!this.view) {
-            return;
-        }
-        if (!data) {
-            this.editable = undefined;
-        }
-        else {
-            this.editable = { stat, data };
-        }
-        const isEditing = this.isEditable(stat);
-        await this.view.setEditable(stat, isEditing);
-        if (!this.editable && this.fileChangeEvents.length && !this.onFileChangesScheduler.isScheduled()) {
-            this.onFileChangesScheduler.schedule();
-        }
-    }
-    async setToCopy(items, cut) {
-        const previouslyCutItems = this.cutItems;
-        this.cutItems = cut ? items : undefined;
-        await this.clipboardService.writeResources(( (items.map(s => s.resource))));
-        this.view?.itemsCopied(items, cut, previouslyCutItems);
-    }
-    isCut(item) {
-        return !!this.cutItems && this.cutItems.some(i => this.uriIdentityService.extUri.isEqual(i.resource, item.resource));
-    }
-    getEditable() {
-        return this.editable;
-    }
-    getEditableData(stat) {
-        return this.editable && this.editable.stat === stat ? this.editable.data : undefined;
-    }
-    isEditable(stat) {
-        return !!this.editable && (this.editable.stat === stat || !stat);
-    }
-    async select(resource, reveal) {
-        if (!this.view) {
-            return;
-        }
-        const ignoreRevealExcludes = reveal === 'force';
-        const fileStat = this.findClosest(resource);
-        if (fileStat) {
-            if (!this.shouldAutoRevealItem(fileStat, ignoreRevealExcludes)) {
-                return;
-            }
-            await this.view.selectResource(fileStat.resource, reveal);
-            return Promise.resolve(undefined);
-        }
-        const options = { resolveTo: [resource], resolveMetadata: this.config.sortOrder === "modified"  };
-        const root = this.findClosestRoot(resource);
-        if (!root) {
-            return undefined;
-        }
-        try {
-            const stat = await this.fileService.resolve(root.resource, options);
-            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, undefined, options.resolveTo);
-            ExplorerItem.mergeLocalWithDisk(modelStat, root);
-            const item = root.find(resource);
-            await this.view.refresh(true, root);
-            if (item && !this.shouldAutoRevealItem(item, ignoreRevealExcludes)) {
-                return;
-            }
-            await this.view.selectResource(item ? item.resource : undefined, reveal);
-        }
-        catch (error) {
-            root.error = error;
-            await this.view.refresh(false, root);
-        }
-    }
-    async refresh(reveal = true) {
-        this.model.roots.forEach(r => r.forgetChildren());
-        if (this.view) {
-            await this.view.refresh(true);
-            const resource = this.editorService.activeEditor?.resource;
-            const autoReveal = this.configurationService.getValue().explorer.autoReveal;
-            if (reveal && resource && autoReveal) {
-                this.select(resource, autoReveal);
-            }
-        }
-    }
-    async onDidRunOperation(e) {
-        const shouldDeepRefresh = this.config.fileNesting.enabled;
-        if (e.isOperation(0 ) || e.isOperation(3 )) {
-            const addedElement = e.target;
-            const parentResource = dirname(addedElement.resource);
-            const parents = this.model.findAll(parentResource);
-            if (parents.length) {
-                await Promise.all(( (parents.map(async (p) => {
-                    const resolveMetadata = this.config.sortOrder === `modified`;
-                    if (!p.isDirectoryResolved) {
-                        const stat = await this.fileService.resolve(p.resource, { resolveMetadata });
-                        if (stat) {
-                            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, p.parent);
-                            ExplorerItem.mergeLocalWithDisk(modelStat, p);
-                        }
-                    }
-                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, addedElement, p.parent);
-                    p.removeChild(childElement);
-                    p.addChild(childElement);
-                    await this.view?.refresh(shouldDeepRefresh, p);
-                }))));
-            }
-        }
-        else if (e.isOperation(2 )) {
-            const oldResource = e.resource;
-            const newElement = e.target;
-            const oldParentResource = dirname(oldResource);
-            const newParentResource = dirname(newElement.resource);
-            const modelElements = this.model.findAll(oldResource);
-            const sameParentMove = modelElements.every(e => !e.nestedParent) && this.uriIdentityService.extUri.isEqual(oldParentResource, newParentResource);
-            if (sameParentMove) {
-                await Promise.all(( (modelElements.map(async (modelElement) => {
-                    modelElement.rename(newElement);
-                    await this.view?.refresh(shouldDeepRefresh, modelElement.parent);
-                }))));
-            }
-            else {
-                const newParents = this.model.findAll(newParentResource);
-                if (newParents.length && modelElements.length) {
-                    await Promise.all(( (modelElements.map(async (modelElement, index) => {
-                        const oldParent = modelElement.parent;
-                        const oldNestedParent = modelElement.nestedParent;
-                        modelElement.move(newParents[index]);
-                        if (oldNestedParent) {
-                            await this.view?.refresh(false, oldNestedParent);
-                        }
-                        await this.view?.refresh(false, oldParent);
-                        await this.view?.refresh(shouldDeepRefresh, newParents[index]);
-                    }))));
-                }
-            }
-        }
-        else if (e.isOperation(1 )) {
-            const modelElements = this.model.findAll(e.resource);
-            await Promise.all(( (modelElements.map(async (modelElement) => {
-                if (modelElement.parent) {
-                    const parent = modelElement.parent;
-                    parent.removeChild(modelElement);
-                    const oldNestedParent = modelElement.nestedParent;
-                    if (oldNestedParent) {
-                        oldNestedParent.removeChild(modelElement);
-                        await this.view?.refresh(false, oldNestedParent);
-                    }
-                    await this.view?.refresh(shouldDeepRefresh, parent);
-                }
-            }))));
-        }
-    }
-    shouldAutoRevealItem(item, ignore) {
-        if (item === undefined || ignore) {
-            return true;
-        }
-        if (this.revealExcludeMatcher.matches(item.resource, name => !!(item.parent && item.parent.getChild(name)))) {
-            return false;
-        }
-        const root = item.root;
-        let currentItem = item.parent;
-        while (currentItem !== root) {
-            if (currentItem === undefined) {
-                return true;
-            }
-            if (this.revealExcludeMatcher.matches(currentItem.resource)) {
-                return false;
-            }
-            currentItem = currentItem.parent;
-        }
-        return true;
-    }
-    async onConfigurationUpdated(event) {
-        if (!event.affectsConfiguration('explorer')) {
-            return;
-        }
-        let shouldRefresh = false;
-        if (event.affectsConfiguration('explorer.fileNesting')) {
-            shouldRefresh = true;
-        }
-        const configuration = this.configurationService.getValue();
-        const configSortOrder = configuration?.explorer?.sortOrder || "default" ;
-        if (this.config.sortOrder !== configSortOrder) {
-            shouldRefresh = this.config.sortOrder !== undefined;
-        }
-        const configLexicographicOptions = configuration?.explorer?.sortOrderLexicographicOptions || "default" ;
-        if (this.config.sortOrderLexicographicOptions !== configLexicographicOptions) {
-            shouldRefresh = shouldRefresh || this.config.sortOrderLexicographicOptions !== undefined;
-        }
-        this.config = configuration.explorer;
-        if (shouldRefresh) {
-            await this.refresh();
-        }
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-};
-ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY = 500;
-ExplorerService = ( (__decorate([
-    ( (__param(0, IFileService))),
-    ( (__param(1, IConfigurationService))),
-    ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IClipboardService))),
-    ( (__param(4, IEditorService))),
-    ( (__param(5, IUriIdentityService))),
-    ( (__param(6, IBulkEditService))),
-    ( (__param(7, IProgressService))),
-    ( (__param(8, IHostService)))
-], ExplorerService)));
-function doesFileEventAffect(item, view, events, types) {
-    for (const [_name, child] of item.children) {
-        if (view.isItemVisible(child)) {
-            if (events.some(e => e.contains(child.resource, ...types))) {
-                return true;
-            }
-            if (child.isDirectory && child.isDirectoryResolved) {
-                if (doesFileEventAffect(child, view, events, types)) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-function getRevealExcludes(configuration) {
-    const revealExcludes = configuration && configuration.explorer && configuration.explorer.autoRevealExclude;
-    if (!revealExcludes) {
-        return {};
-    }
-    return revealExcludes;
-}
-( (Registry.as(EditorExtensions.EditorFactory))).registerFileEditorFactory({
-    typeId: FILE_EDITOR_INPUT_ID,
-    createFileEditor: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService) => {
-        return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents);
-    },
-    isFileEditor: (obj) => {
-        return obj instanceof FileEditorInput;
-    }
-});
-const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
-const hotExitConfiguration = isNative ?
-    {
-        'type': 'string',
-        'scope': 1 ,
-        'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
-        'default': HotExitConfiguration.ON_EXIT,
-        'markdownEnumDescriptions': [
-            ( (localize(
-            'hotExit.off',
-            'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
-        ))),
-            ( (localize(
-            'hotExit.onExit',
-            'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu). All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
-        ))),
-            ( (localize(
-            'hotExit.onExitAndWindowClose',
-            'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu), and also for any window with a folder opened regardless of whether it\'s the last window. All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
-        )))
-        ],
-        'description': ( (localize(
-            'hotExit',
-            "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
-            HotExitConfiguration.ON_EXIT,
-            HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
-        )))
-    } : {
-    'type': 'string',
-    'scope': 1 ,
-    'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
-    'default': HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE,
-    'markdownEnumDescriptions': [
-        ( (localize(
-        'hotExit.off',
-        'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
-    ))),
-        ( (localize(
-        'hotExit.onExitAndWindowCloseBrowser',
-        'Hot exit will be triggered when the browser quits or the window or tab is closed.'
-    )))
-    ],
-    'description': ( (localize(
-        'hotExit',
-        "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
-        HotExitConfiguration.ON_EXIT,
-        HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
-    )))
-};
-configurationRegistry.registerConfiguration({
-    'id': 'files',
-    'order': 9,
-    'title': ( (localize('filesConfigurationTitle', "Files"))),
-    'type': 'object',
-    'properties': {
-        [FILES_EXCLUDE_CONFIG]: {
-            'type': 'object',
-            'markdownDescription': ( (localize(
-                'exclude',
-                "Configure [glob patterns](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options) for excluding files and folders. For example, the File Explorer decides which files and folders to show or hide based on this setting. Refer to the `#search.exclude#` setting to define search-specific excludes. Refer to the `#explorer.excludeGitIgnore#` setting for ignoring files based on your `.gitignore`."
-            ))),
-            'default': {
-                ...{ '**/.git': true, '**/.svn': true, '**/.hg': true, '**/CVS': true, '**/.DS_Store': true, '**/Thumbs.db': true },
-                ...(isWeb ? { '**/*.crswap': true  } : undefined)
-            },
-            'scope': 4 ,
-            'additionalProperties': {
-                'anyOf': [
-                    {
-                        'type': 'boolean',
-                        'enum': [true, false],
-                        'enumDescriptions': [( (localize('trueDescription', "Enable the pattern."))), ( (localize('falseDescription', "Disable the pattern.")))],
-                        'description': ( (localize(
-                            'files.exclude.boolean',
-                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
-                        ))),
-                    },
-                    {
-                        'type': 'object',
-                        'properties': {
-                            'when': {
-                                'type': 'string',
-                                'pattern': '\\w*\\$\\(basename\\)\\w*',
-                                'default': '$(basename).ext',
-                                'markdownDescription': ( (localize(
-                                    { key: 'files.exclude.when', comment: ['\\$(basename) should not be translated'] },
-                                    "Additional check on the siblings of a matching file. Use \\$(basename) as variable for the matching file name."
-                                )))
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        [FILES_ASSOCIATIONS_CONFIG]: {
-            'type': 'object',
-            'markdownDescription': ( (localize(
-                'associations',
-                "Configure file associations to languages (for example `\"*.extension\": \"html\"`). These have precedence over the default associations of the languages installed."
-            ))),
-            'additionalProperties': {
-                'type': 'string'
-            }
-        },
-        'files.encoding': {
-            'type': 'string',
-            'enum': ( (Object.keys(SUPPORTED_ENCODINGS))),
-            'default': 'utf8',
-            'description': ( (localize(
-                'encoding',
-                "The default character set encoding to use when reading and writing files. This setting can also be configured per language."
-            ))),
-            'scope': 5 ,
-            'enumDescriptions': ( (( (Object.keys(SUPPORTED_ENCODINGS))).map(key => SUPPORTED_ENCODINGS[key].labelLong))),
-            'enumItemLabels': ( (( (Object.keys(SUPPORTED_ENCODINGS))).map(key => SUPPORTED_ENCODINGS[key].labelLong)))
-        },
-        'files.autoGuessEncoding': {
-            'type': 'boolean',
-            'default': false,
-            'markdownDescription': ( (localize(
-                'autoGuessEncoding',
-                "When enabled, the editor will attempt to guess the character set encoding when opening files. This setting can also be configured per language. Note, this setting is not respected by text search. Only {0} is respected.",
-                '`#files.encoding#`'
-            ))),
-            'scope': 5
-        },
-        'files.eol': {
-            'type': 'string',
-            'enum': [
-                '\n',
-                '\r\n',
-                'auto'
-            ],
-            'enumDescriptions': [
-                ( (localize('eol.LF', "LF"))),
-                ( (localize('eol.CRLF', "CRLF"))),
-                ( (localize('eol.auto', "Uses operating system specific end of line character.")))
-            ],
-            'default': 'auto',
-            'description': ( (localize('eol', "The default end of line character."))),
-            'scope': 5
-        },
-        'files.enableTrash': {
-            'type': 'boolean',
-            'default': true,
-            'description': ( (localize(
-                'useTrash',
-                "Moves files/folders to the OS trash (recycle bin on Windows) when deleting. Disabling this will delete files/folders permanently."
-            )))
-        },
-        'files.trimTrailingWhitespace': {
-            'type': 'boolean',
-            'default': false,
-            'description': ( (localize(
-                'trimTrailingWhitespace',
-                "When enabled, will trim trailing whitespace when saving a file."
-            ))),
-            'scope': 5
-        },
-        'files.insertFinalNewline': {
-            'type': 'boolean',
-            'default': false,
-            'description': ( (localize(
-                'insertFinalNewline',
-                "When enabled, insert a final new line at the end of the file when saving it."
-            ))),
-            'scope': 5
-        },
-        'files.trimFinalNewlines': {
-            'type': 'boolean',
-            'default': false,
-            'description': ( (localize(
-                'trimFinalNewlines',
-                "When enabled, will trim all new lines after the final new line at the end of the file when saving it."
-            ))),
-            scope: 5 ,
-        },
-        'files.autoSave': {
-            'type': 'string',
-            'enum': [AutoSaveConfiguration.OFF, AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE],
-            'markdownEnumDescriptions': [
-                ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.off' },
-                "An editor with changes is never automatically saved."
-            ))),
-                ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.afterDelay' },
-                "An editor with changes is automatically saved after the configured `#files.autoSaveDelay#`."
-            ))),
-                ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onFocusChange' },
-                "An editor with changes is automatically saved when the editor loses focus."
-            ))),
-                ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onWindowChange' },
-                "An editor with changes is automatically saved when the window loses focus."
-            )))
-            ],
-            'default': isWeb ? AutoSaveConfiguration.AFTER_DELAY : AutoSaveConfiguration.OFF,
-            'markdownDescription': ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSave' },
-                "Controls [auto save](https://code.visualstudio.com/docs/editor/codebasics#_save-auto-save) of editors that have unsaved changes.",
-                AutoSaveConfiguration.OFF,
-                AutoSaveConfiguration.AFTER_DELAY,
-                AutoSaveConfiguration.ON_FOCUS_CHANGE,
-                AutoSaveConfiguration.ON_WINDOW_CHANGE,
-                AutoSaveConfiguration.AFTER_DELAY
-            )))
-        },
-        'files.autoSaveDelay': {
-            'type': 'number',
-            'default': 1000,
-            'minimum': 0,
-            'markdownDescription': ( (localize(
-                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSaveDelay' },
-                "Controls the delay in milliseconds after which an editor with unsaved changes is saved automatically. Only applies when `#files.autoSave#` is set to `{0}`.",
-                AutoSaveConfiguration.AFTER_DELAY
-            )))
-        },
-        'files.watcherExclude': {
-            'type': 'object',
-            'default': { '**/.git/objects/**': true, '**/.git/subtree-cache/**': true, '**/node_modules/*/**': true, '**/.hg/store/**': true },
-            'markdownDescription': ( (localize(
-                'watcherExclude',
-                "Configure paths or glob patterns to exclude from file watching. Paths can either be relative to the watched folder or absolute. Glob patterns are matched relative from the watched folder. When you experience the file watcher process consuming a lot of CPU, make sure to exclude large folders that are of less interest (such as build output folders)."
-            ))),
-            'scope': 4
-        },
-        'files.watcherInclude': {
-            'type': 'array',
-            'items': {
-                'type': 'string'
-            },
-            'default': [],
-            'description': ( (localize(
-                'watcherInclude',
-                "Configure extra paths to watch for changes inside the workspace. By default, all workspace folders will be watched recursively, except for folders that are symbolic links. You can explicitly add absolute or relative paths to support watching folders that are symbolic links. Relative paths will be resolved to an absolute path using the currently opened workspace."
-            ))),
-            'scope': 4
-        },
-        'files.hotExit': hotExitConfiguration,
-        'files.defaultLanguage': {
-            'type': 'string',
-            'markdownDescription': ( (localize(
-                'defaultLanguage',
-                "The default language identifier that is assigned to new files. If configured to `${activeEditorLanguage}`, will use the language identifier of the currently active text editor if any."
-            )))
-        },
-        'files.maxMemoryForLargeFilesMB': {
-            'type': 'number',
-            'default': 4096,
-            'minimum': 0,
-            'markdownDescription': ( (localize(
-                'maxMemoryForLargeFilesMB',
-                "Controls the memory available to VS Code after restart when trying to open large files. Same effect as specifying `--max-memory=NEWSIZE` on the command line."
-            ))),
-            included: isNative
-        },
-        'files.restoreUndoStack': {
-            'type': 'boolean',
-            'description': ( (localize(
-                'files.restoreUndoStack',
-                "Restore the undo stack when a file is reopened."
-            ))),
-            'default': true
-        },
-        'files.saveConflictResolution': {
-            'type': 'string',
-            'enum': [
-                'askUser',
-                'overwriteFileOnDisk'
-            ],
-            'enumDescriptions': [
-                ( (localize(
-                'askUser',
-                "Will refuse to save and ask for resolving the save conflict manually."
-            ))),
-                ( (localize(
-                'overwriteFileOnDisk',
-                "Will resolve the save conflict by overwriting the file on disk with the changes in the editor."
-            )))
-            ],
-            'description': ( (localize(
-                'files.saveConflictResolution',
-                "A save conflict can occur when a file is saved to disk that was changed by another program in the meantime. To prevent data loss, the user is asked to compare the changes in the editor with the version on disk. This setting should only be changed if you frequently encounter save conflict errors and may result in data loss if used without caution."
-            ))),
-            'default': 'askUser',
-            'scope': 5
-        },
-        'files.simpleDialog.enable': {
-            'type': 'boolean',
-            'description': ( (localize(
-                'files.simpleDialog.enable',
-                "Enables the simple file dialog. The simple file dialog replaces the system file dialog when enabled."
-            ))),
-            'default': false
-        },
-        'files.participants.timeout': {
-            type: 'number',
-            default: 60000,
-            markdownDescription: ( (localize(
-                'files.participants.timeout',
-                "Timeout in milliseconds after which file participants for create, rename, and delete are cancelled. Use `0` to disable participants."
-            ))),
-        }
-    }
-});
-configurationRegistry.registerConfiguration({
-    ...editorConfigurationBaseNode,
-    properties: {
-        'editor.formatOnSave': {
-            'type': 'boolean',
-            'description': ( (localize(
-                'formatOnSave',
-                "Format a file on save. A formatter must be available, the file must not be saved after delay, and the editor must not be shutting down."
-            ))),
-            'scope': 5 ,
-        },
-        'editor.formatOnSaveMode': {
-            'type': 'string',
-            'default': 'file',
-            'enum': [
-                'file',
-                'modifications',
-                'modificationsIfAvailable'
-            ],
-            'enumDescriptions': [
-                ( (localize(
-                { key: 'everything', comment: ['This is the description of an option'] },
-                "Format the whole file."
-            ))),
-                ( (localize(
-                { key: 'modification', comment: ['This is the description of an option'] },
-                "Format modifications (requires source control)."
-            ))),
-                ( (localize(
-                { key: 'modificationIfAvailable', comment: ['This is the description of an option'] },
-                "Will attempt to format modifications only (requires source control). If source control can't be used, then the whole file will be formatted."
-            ))),
-            ],
-            'markdownDescription': ( (localize(
-                'formatOnSaveMode',
-                "Controls if format on save formats the whole file or only modifications. Only applies when `#editor.formatOnSave#` is enabled."
-            ))),
-            'scope': 5 ,
-        },
-    }
-});
-RedoCommand.addImplementation(110, 'explorer', (accessor) => {
-    const undoRedoService = accessor.get(IUndoRedoService);
-    const explorerService = accessor.get(IExplorerService);
-    const configurationService = accessor.get(IConfigurationService);
-    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
-    if (explorerService.hasViewFocus() && undoRedoService.canRedo(UNDO_REDO_SOURCE) && explorerCanUndo) {
-        undoRedoService.redo(UNDO_REDO_SOURCE);
-        return true;
-    }
-    return false;
-});
-ModesRegistry.registerLanguage({
-    id: BINARY_TEXT_FILE_MODE,
-    aliases: ['Binary'],
-    mimetypes: ['text/x-code-binary']
-});
-class File {
-    constructor(getContent) {
-        this.getContent = getContent;
-        this.ctime = Date.now();
-        this.mtime = Date.now();
-        this.size = 0;
-        this.type = FileType.File;
-    }
-}
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-class SimpleTextFileSystemProvider {
-    constructor() {
-        this.onDidChangeCapabilities = Event.None;
-        this.capabilities = 2  | 1024 ;
-        this.onDidChangeFile = Event.None;
-        this.onDidWatchError = Event.None;
-    }
-    async readFile(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
-                return encoder.encode(content);
-            }
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    async writeFile(resource, content, opts) {
-        try {
-            await this.setFileContent(resource, decoder.decode(content), opts);
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-    }
-    watch() {
-        return Disposable.None;
-    }
-    async stat(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
-                return {
-                    type: FileType.File,
-                    size: encoder.encode(content).length,
-                    ctime: Date.now(),
-                    mtime: Date.now()
-                };
-            }
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    async mkdir() {
-    }
-    readdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    delete() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    rename() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-}
-class ExtensionFileSystemProviderWithFileReadWriteCapability {
-    constructor() {
-        this.capabilities = 2  | 1024  | 2048 ;
-        this.onDidChangeFile = Event.None;
-        this.onDidChangeCapabilities = Event.None;
-        this.files = new Map();
-    }
-    async stat(resource) {
-        const file = this.files.get(( resource.toString()));
-        if (file != null) {
-            return file;
-        }
-        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    async readFile(resource) {
-        const file = this.files.get(( resource.toString()));
-        if (file != null) {
-            return encoder.encode(await file.getContent());
-        }
-        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    watch() {
-        return Disposable.None;
-    }
-    registerFile(resource, getContent) {
-        this.files.set(( resource.toString()), new File(getContent));
-        return {
-            dispose: () => {
-                this.files.delete(( resource.toString()));
-            }
-        };
-    }
-    async writeFile() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    async mkdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    readdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    async delete() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    async rename() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-}
-const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
-class OverlayFileSystemProvider {
-    constructor(_default) {
-        this._default = _default;
-        this.others = [];
-        this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
-        this._onDidChangeFile = new Emitter();
-        this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
-        this.capabilities = 2  | 1024 ;
-        _default.onDidChangeFile((e) => {
-            this._onDidChangeFile.fire(e);
-        });
-    }
-    register(delegate) {
-        this.others.push(delegate);
-        const disposableStore = new DisposableStore();
-        disposableStore.add(delegate.onDidChangeFile(e => {
-            this._onDidChangeFile.fire(e);
-        }));
-        disposableStore.add({
-            dispose: () => {
-                const index = this.others.indexOf(delegate);
-                if (index >= 0) {
-                    this.others.splice(index, 1);
-                }
-            }
-        });
-        return disposableStore;
-    }
-    get delegates() {
-        return [this._default, ...this.others];
-    }
-    async readFromDelegates(caller) {
-        let firstError;
-        for (const delegate of this.delegates) {
-            try {
-                return await caller(delegate);
-            }
-            catch (err) {
-                firstError ?? (firstError = err);
-                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.FileNotFound) {
-                    continue;
-                }
-                throw err;
-            }
-        }
-        throw firstError;
-    }
-    async writeToDelegates(caller) {
-        await Promise.all(( this.delegates.map(async (delegate) => {
-            if (((delegate.capabilities & 2048) ) === 0) {
-                await caller(delegate);
-            }
-        })));
-    }
-    async stat(resource) {
-        return this.readFromDelegates(delegate => delegate.stat(resource));
-    }
-    async readFile(resource) {
-        return this.readFromDelegates(delegate => delegate.readFile(resource));
-    }
-    async readdir(resource) {
-        return this.readFromDelegates(delegate => delegate.readdir(resource));
-    }
-    watch(resource, opts) {
-        const store = new DisposableStore();
-        for (const delegate of this.delegates) {
-            store.add(delegate.watch(resource, opts));
-        }
-        return store;
-    }
-    async writeFile(resource, content, opts) {
-        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
-    }
-    async mkdir(resource) {
-        await this.writeToDelegates(delegate => delegate.mkdir(resource));
-    }
-    async delete(resource, opts) {
-        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
-    }
-    async rename(from, to, opts) {
-        await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
-    }
-}
-const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
-let MemoryFileService = class MemoryFileService extends FileService {
-    constructor(logService) {
-        super(logService);
-        const userMemoryFileSystem = new InMemoryFileSystemProvider();
-        this.registerProvider('user', userMemoryFileSystem);
-        this.registerProvider('extension', extensionFileSystemProvider);
-        this.registerProvider('cache', new InMemoryFileSystemProvider());
-        this.registerProvider('logs', new InMemoryFileSystemProvider());
-        this.registerProvider('file', fileSystemProvider);
-    }
-};
-MemoryFileService = __decorate([
-    ( __param(0, ILogService))
-], MemoryFileService);
-function getServiceOverride() {
-    return {
-        [( IFileService.toString())]: new SyncDescriptor(MemoryFileService),
-        [( ITextFileService.toString())]: new SyncDescriptor(BrowserTextFileService)
-    };
-}
-function registerExtensionFile(extensionLocation, path, getContent) {
-    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
-}
-function registerFileSystemOverlay(provider) {
-    return fileSystemProvider.register(provider);
-}
-export { FileSystemProviderError, FileSystemProviderErrorCode, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };