@codingame/monaco-vscode-api 1.68.7 → 1.69.0

package/dist/files.js

@@ -0,0 +1,1325 @@
+import { _ as __decorate, a as __param } from './tslib.es6.js';
+import { n as format2, o as getServiceMachineId, E as Emitter, p as ResourceQueue, q as isReadableStream, s as peekStream, t as peekReadable, v as bufferToReadable, x as streamToBuffer, y as consumeStream, z as transform, A as isReadableBufferedStream, C as listenStream, D as bufferedStreamToBuffer, F as readableToBuffer, u as unsupported, G as newWriteableBufferStream, H as newWriteableStream } from './missing-services.js';
+import { I as IFileService, j as IProductService, S as Services, z as FileChangesEvent, B as FileOperationError, D as hasOpenReadWriteCloseCapability, E as hasReadWriteCapability, G as hasFileReadStreamCapability, H as toFileSystemProviderErrorCode, q as FileSystemProviderErrorCode, J as ensureFileSystemProviderError, F as FileType, a as FilePermission, K as etag, L as FileOperationEvent, M as toFileOperationResult, O as ETAG_DISABLED, P as hasFileAtomicReadCapability, Q as NotModifiedSinceFileOperationError, R as hasFileFolderCopyCapability, T as hasFileCloneCapability, U as FileSystemProviderError, V as createFileSystemProviderError, C as CancellationTokenSource } from './services2.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { isAbsolutePath, extUri, extUriIgnorePathCase, basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.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, RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { bh as supportsTelemetry, bi as getTelemetryLevel, bd as DEFAULT_EXTENSION, E as Disposable$1 } from './extHost.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+function getRemoteAuthority(uri) {
+    return uri.scheme === Schemas.vscodeRemote ? uri.authority : undefined;
+}
+function getRemoteServerRootPath(product) {
+    return `/${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
+}
+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.`);
+        }
+        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 Error()));
+            error.name = 'ENOPRO';
+            error.message = ( (localize(
+                'noProviderFound',
+                "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);
+            }
+            const message = ( (localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                 (ensureFileSystemProviderError(error).toString())
+            )));
+            if (error instanceof NotModifiedSinceFileOperationError) {
+                throw new NotModifiedSinceFileOperationError(message, error.stat, options);
+            }
+            else {
+                throw 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 => ( (new FileOperationError( (localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                 (ensureFileSystemProviderError(error).toString())
+            )), toFileOperationResult(error), 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 => ( (new FileOperationError( (localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                 (ensureFileSystemProviderError(error).toString())
+            )), toFileOperationResult(error), 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 FileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult);
+            }
+        }
+    }
+    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)));
+class File$1 {
+    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.capabilities = 2
+            | 1024 ;
+        this.onDidChangeCapabilities = Event.None;
+        this.root = ( (new Directory('')));
+        this._onDidChangeFile = this._register(( (new Emitter())));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._bufferedChanges = [];
+    }
+    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 new FileSystemProviderError('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 new FileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
+        }
+        if (!entry && !opts.create) {
+            throw new FileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (entry && opts.create && !opts.overwrite) {
+            throw new FileSystemProviderError('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 new FileSystemProviderError('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 new FileSystemProviderError('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 new FileSystemProviderError('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 new FileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof File$1) {
+            return entry;
+        }
+        throw new FileSystemProviderError('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);
+    }
+}
+const WEB_EXTENSION_RESOURCE_END_POINT = 'web-extension-resource';
+const IExtensionResourceLoaderService = ( (createDecorator('extensionResourceLoaderService')));
+class AbstractExtensionResourceLoaderService {
+    constructor(_fileService, _storageService, _productService, _environmentService, _configurationService) {
+        this._fileService = _fileService;
+        this._storageService = _storageService;
+        this._productService = _productService;
+        this._environmentService = _environmentService;
+        this._configurationService = _configurationService;
+        this._webExtensionResourceEndPoint = `${getRemoteServerRootPath(_productService)}/${WEB_EXTENSION_RESOURCE_END_POINT}/`;
+        if (_productService.extensionsGallery) {
+            this._extensionGalleryResourceUrlTemplate = _productService.extensionsGallery.resourceUrlTemplate;
+            this._extensionGalleryAuthority = this._extensionGalleryResourceUrlTemplate ? this._getExtensionGalleryAuthority(( (URI.parse(this._extensionGalleryResourceUrlTemplate)))) : undefined;
+        }
+    }
+    get supportsExtensionGalleryResources() {
+        return this._extensionGalleryResourceUrlTemplate !== undefined;
+    }
+    getExtensionGalleryResourceURL(galleryExtension, path) {
+        if (this._extensionGalleryResourceUrlTemplate) {
+            const uri = ( (URI.parse(
+                format2(this._extensionGalleryResourceUrlTemplate, { publisher: galleryExtension.publisher, name: galleryExtension.name, version: galleryExtension.version, path: 'extension' })
+            )));
+            return this._isWebExtensionResourceEndPoint(uri) ? uri.with({ scheme: RemoteAuthorities.getPreferredWebSchema() }) : uri;
+        }
+        return undefined;
+    }
+    isExtensionGalleryResource(uri) {
+        return this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
+    }
+    async getExtensionGalleryRequestHeaders() {
+        const headers = {
+            'X-Client-Name': `${this._productService.applicationName}${isWeb ? '-web' : ''}`,
+            'X-Client-Version': this._productService.version
+        };
+        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
+            headers['X-Machine-Id'] = await this._getServiceMachineId();
+        }
+        if (this._productService.commit) {
+            headers['X-Client-Commit'] = this._productService.commit;
+        }
+        return headers;
+    }
+    _getServiceMachineId() {
+        if (!this._serviceMachineIdPromise) {
+            this._serviceMachineIdPromise = getServiceMachineId(this._environmentService, this._fileService, this._storageService);
+        }
+        return this._serviceMachineIdPromise;
+    }
+    _getExtensionGalleryAuthority(uri) {
+        if (this._isWebExtensionResourceEndPoint(uri)) {
+            return uri.authority;
+        }
+        const index = uri.authority.indexOf('.');
+        return index !== -1 ? uri.authority.substring(index + 1) : undefined;
+    }
+    _isWebExtensionResourceEndPoint(uri) {
+        return uri.path.startsWith(this._webExtensionResourceEndPoint);
+    }
+}
+let SimpleExtensionResourceLoaderService = class SimpleExtensionResourceLoaderService extends AbstractExtensionResourceLoaderService {
+    constructor(fileService, storageService, productService, environmentService, configurationService) {
+        super(fileService, storageService, productService, environmentService, configurationService);
+    }
+    async readExtensionResource(uri) {
+        const result = await this._fileService.readFile(uri);
+        return ( result.value.toString());
+    }
+};
+SimpleExtensionResourceLoaderService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IProductService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IConfigurationService))
+], SimpleExtensionResourceLoaderService));
+registerSingleton(IExtensionResourceLoaderService, SimpleExtensionResourceLoaderService);
+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();
+class ExtensionFileSystemProviderWithFileReadWriteCapability {
+    constructor() {
+        this.capabilities = 2  | 1024 ;
+        this.onDidChangeFile = Event.None;
+        this.onDidChangeCapabilities = Event.None;
+        this.onDidWatchError = Event.None;
+        this.writeFile = unsupported;
+        this.mkdir = unsupported;
+        this.readdir = unsupported;
+        this.delete = unsupported;
+        this.rename = unsupported;
+        this.files = new Map();
+    }
+    async stat(resource) {
+        const file = this.files.get(( resource.toString()));
+        if (file != null) {
+            return file;
+        }
+        throw new FileSystemProviderError('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 new FileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    watch() {
+        return {
+            dispose() { }
+        };
+    }
+    registerFile(resource, getContent) {
+        this.files.set(( resource.toString()), new File(getContent));
+        return new Disposable$1(() => {
+            this.files.delete(( resource.toString()));
+        });
+    }
+}
+const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
+let MemoryFileService = class MemoryFileService extends FileService {
+    constructor(logService) {
+        super(logService);
+        this.registerProvider(Schemas.file, new InMemoryFileSystemProvider());
+        const extension = Services.get().extension ?? DEFAULT_EXTENSION;
+        this.registerProvider(extension.extensionLocation.scheme, extensionFileSystemProvider);
+    }
+};
+MemoryFileService = ( __decorate([
+    ( __param(0, ILogService))
+], MemoryFileService));
+function registerExtensionFile(resource, getContent) {
+    return extensionFileSystemProvider.registerFile(resource, getContent);
+}
+function getServiceOverride() {
+    return {
+        [( IFileService.toString())]: new SyncDescriptor(MemoryFileService),
+        [( IExtensionResourceLoaderService.toString())]: new SyncDescriptor(SimpleExtensionResourceLoaderService)
+    };
+}
+export { IExtensionResourceLoaderService as I, getRemoteAuthority as a, getServiceOverride as g, registerExtensionFile as r };