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

package/dist/vscode/vs/platform/files/common/fileService.js

@@ -0,0 +1,920 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ResourceQueue, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { VSBuffer, bufferToReadable, streamToBuffer, newWriteableBufferStream, bufferedStreamToBuffer, readableToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { mark } from '../../../base/common/performance.js';
+import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isReadableStream, peekStream, peekReadable, consumeStream, transform, isReadableBufferedStream, listenStream, newWriteableStream } from '../../../base/common/stream.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, FilePermission, etag, FileOperationEvent, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileCloneCapability } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { readFileIntoStream } from './io.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
+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));
+export { FileService };