@codingame/monaco-vscode-files-service-override 25.1.2 → 26.0.0

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

@@ -14,7 +14,7 @@ import { mark } from '@codingame/monaco-vscode-api/vscode/vs/base/common/perform
 import { isAbsolutePath, extUri, extUriIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, FileOperationResult, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, etag, FilePermission, FileSystemProviderCapabilities, hasFileRealpathCapability, FileOperationEvent, FileOperation, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, FileOperationResult, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, etag, FilePermission, FileSystemProviderCapabilities, hasFileRealpathCapability, FileOperationEvent, FileOperation, hasFileAtomicWriteCapability, toFileOperationResult, hasFileAppendCapability, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
@@ -39,8 +39,7 @@ async function mkdirp(providerExtUri, provider, directory) {
                 ))));
             }
             break;
-        }
-        catch (error) {
+        } catch (error) {
             if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
                 throw error;
             }
@@ -52,8 +51,7 @@ async function mkdirp(providerExtUri, provider, directory) {
         directory = providerExtUri.joinPath(directory, directoriesToCreate[i]);
         try {
             await provider.mkdir(directory);
-        }
-        catch (error) {
+        } catch (error) {
             if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
                 throw error;
             }
@@ -61,7 +59,9 @@ async function mkdirp(providerExtUri, provider, directory) {
     }
 }
 let FileService = class FileService extends Disposable {
-    static { FileService_1 = this; }
+    static {
+        FileService_1 = this;
+    }
     constructor(logService) {
         super();
         this.logService = logService;
@@ -90,7 +90,11 @@ let FileService = class FileService extends Disposable {
         mark(`code/registerFilesystem/${scheme}`);
         const providerDisposables = ( new DisposableStore());
         this.provider.set(scheme, provider);
-        this._onDidChangeFileSystemProviderRegistrations.fire({ added: true, scheme, provider });
+        this._onDidChangeFileSystemProviderRegistrations.fire({
+            added: true,
+            scheme,
+            provider
+        });
         providerDisposables.add(provider.onDidChangeFile(changes => {
             const event = ( new FileChangesEvent(changes, !this.isPathCaseSensitive(provider)));
             this.internalOnDidFilesChange.fire(event);
@@ -98,12 +102,23 @@ let FileService = class FileService extends Disposable {
                 this._onDidUncorrelatedFilesChange.fire(event);
             }
         }));
-        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 })));
+        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._onDidChangeFileSystemProviderRegistrations.fire({
+                added: false,
+                scheme,
+                provider
+            });
             this.provider.delete(scheme);
             dispose(providerDisposables);
         });
@@ -117,7 +132,7 @@ let FileService = class FileService extends Disposable {
             scheme,
             join(promise) {
                 joiners.push(promise);
-            },
+            }
         });
         if (( this.provider.has(scheme))) {
             return;
@@ -136,10 +151,10 @@ let FileService = class FileService extends Disposable {
         return !!(provider && (provider.capabilities & capability));
     }
     listCapabilities() {
-        return ( Iterable.map(
-            this.provider,
-            ([scheme, provider]) => ({ scheme, capabilities: provider.capabilities })
-        ));
+        return ( Iterable.map(this.provider, ([scheme, provider]) => ({
+            scheme,
+            capabilities: provider.capabilities
+        })));
     }
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
@@ -183,8 +198,7 @@ let FileService = class FileService extends Disposable {
     async resolve(resource, options) {
         try {
             return await this.doResolveFile(resource, options);
-        }
-        catch (error) {
+        } catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
                 throw ( new FileOperationError(( localize(
                     1916,
@@ -203,25 +217,37 @@ let FileService = class FileService extends Disposable {
         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);
+        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;
             }
-            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 {
+            providerExtUri
+        } = this.getExtUri(provider);
         const fileStat = {
             resource,
             name: providerExtUri.basename(resource),
@@ -234,7 +260,10 @@ let FileService = class FileService extends Disposable {
             readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & FileSystemProviderCapabilities.Readonly),
             locked: Boolean((stat.permissions ?? 0) & FilePermission.Locked),
             executable: Boolean((stat.permissions ?? 0) & FilePermission.Executable),
-            etag: etag({ mtime: stat.mtime, size: stat.size }),
+            etag: etag({
+                mtime: stat.mtime,
+                size: stat.size
+            }),
             children: undefined
         };
         if (fileStat.isDirectory && recurse(fileStat, siblings)) {
@@ -243,17 +272,24 @@ let FileService = class FileService extends Disposable {
                 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) {
+                        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) {
+            } catch (error) {
                 this.logService.trace(error);
                 fileStat.children = [];
             }
@@ -262,26 +298,40 @@ let FileService = class FileService extends Disposable {
         return fileStat;
     }
     async resolveAll(toResolve) {
-        return Promises.settled(( toResolve.map(async (entry) => {
+        return Promises.settled(( toResolve.map(async entry => {
             try {
-                return { stat: await this.doResolveFile(entry.resource, entry.options), success: true };
-            }
-            catch (error) {
+                return {
+                    stat: await this.doResolveFile(entry.resource, entry.options),
+                    success: true
+                };
+            } catch (error) {
                 this.logService.trace(error);
-                return { stat: undefined, success: false };
+                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 );
+        return this.toFileStat(
+            provider,
+            resource,
+            stat,
+            undefined,
+            true,
+            () => false
+        );
     }
     async realpath(resource) {
         const provider = await this.withProvider(resource);
         if (hasFileRealpathCapability(provider)) {
             const realpath = await provider.realpath(resource);
-            return resource.with({ path: realpath });
+            return resource.with({
+                path: realpath
+            });
         }
         return undefined;
     }
@@ -290,16 +340,14 @@ let FileService = class FileService extends Disposable {
         try {
             const stat = await provider.stat(resource);
             return !!stat;
-        }
-        catch (error) {
+        } catch (error) {
             return false;
         }
     }
     async canCreateFile(resource, options) {
         try {
             await this.doValidateCreateFile(resource, options);
-        }
-        catch (error) {
+        } catch (error) {
             return error;
         }
         return true;
@@ -313,7 +361,7 @@ let FileService = class FileService extends Disposable {
             )), FileOperationResult.FILE_MODIFIED_SINCE, options));
         }
     }
-    async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), 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, FileOperation.CREATE, fileStat)));
@@ -321,34 +369,49 @@ let FileService = class FileService extends Disposable {
     }
     async writeFile(resource, bufferOrReadableOrStream, options) {
         const provider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(resource), resource);
-        const { providerExtUri } = this.getExtUri(provider);
+        const {
+            providerExtUri
+        } = this.getExtUri(provider);
         let writeFileOptions = options;
         if (hasFileAtomicWriteCapability(provider) && !writeFileOptions?.atomic) {
             const enforcedAtomicWrite = provider.enforceAtomicWriteFile?.(resource);
             if (enforcedAtomicWrite) {
-                writeFileOptions = { ...options, atomic: enforcedAtomicWrite };
+                writeFileOptions = {
+                    ...options,
+                    atomic: enforcedAtomicWrite
+                };
             }
         }
         try {
-            let { stat, buffer: bufferOrReadableOrStreamOrBufferedStream } = await this.validateWriteFile(provider, resource, bufferOrReadableOrStream, writeFileOptions);
+            let {
+                stat,
+                buffer: bufferOrReadableOrStreamOrBufferedStream
+            } = await this.validateWriteFile(provider, resource, bufferOrReadableOrStream, writeFileOptions);
             if (!stat) {
                 await this.mkdirp(provider, providerExtUri.dirname(resource));
             }
             if (!bufferOrReadableOrStreamOrBufferedStream) {
                 bufferOrReadableOrStreamOrBufferedStream = await this.peekBufferForWriting(provider, bufferOrReadableOrStream);
             }
-            if (!hasOpenReadWriteCloseCapability(provider) ||
-                (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) ||
-                (hasReadWriteCapability(provider) && hasFileAtomicWriteCapability(provider) && writeFileOptions?.atomic)
-            ) {
-                await this.doWriteUnbuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream);
+            if (
+            !hasOpenReadWriteCloseCapability(provider) || (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) || (hasReadWriteCapability(provider) && hasFileAtomicWriteCapability(provider) && writeFileOptions?.atomic)) {
+                await this.doWriteUnbuffered(
+                    provider,
+                    resource,
+                    writeFileOptions,
+                    bufferOrReadableOrStreamOrBufferedStream
+                );
             }
             else {
-                await this.doWriteBuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
+                await this.doWriteBuffered(
+                    provider,
+                    resource,
+                    writeFileOptions,
+                    bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream
+                );
             }
             this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.WRITE)));
-        }
-        catch (error) {
+        } catch (error) {
             throw ( new FileOperationError(( localize(
                 1918,
                 "Unable to write file '{0}' ({1})",
@@ -356,7 +419,9 @@ let FileService = class FileService extends Disposable {
                 (ensureFileSystemProviderError(error).toString())
             )), toFileOperationResult(error), writeFileOptions));
         }
-        return this.resolve(resource, { resolveMetadata: true });
+        return this.resolve(resource, {
+            resolveMetadata: true
+        });
     }
     async peekBufferForWriting(provider, bufferOrReadableOrStream) {
         let peekResult;
@@ -365,16 +430,13 @@ let FileService = class FileService extends Disposable {
                 const bufferedStream = await peekStream(bufferOrReadableOrStream, 3);
                 if (bufferedStream.ended) {
                     peekResult = VSBuffer.concat(bufferedStream.buffer);
-                }
-                else {
+                } else {
                     peekResult = bufferedStream;
                 }
-            }
-            else {
+            } else {
                 peekResult = peekReadable(bufferOrReadableOrStream, data => VSBuffer.concat(data), 3);
             }
-        }
-        else {
+        } else {
             peekResult = bufferOrReadableOrStream;
         }
         return peekResult;
@@ -388,25 +450,32 @@ let FileService = class FileService extends Disposable {
                 this.resourceForError(resource)
             ))));
         }
+        if (options?.append && !hasFileAppendCapability(provider)) {
+            throw ( new FileOperationError(( localize(
+                1920,
+                "Filesystem provider for scheme '{0}' does not does not support append",
+                this.resourceForError(resource)
+            )), FileOperationResult.FILE_PERMISSION_DENIED));
+        }
         const atomic = !!options?.atomic;
         if (atomic) {
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite)) {
                 throw ( new Error(( localize(
-                    1920,
+                    1921,
                     "Unable to atomically write file '{0}' because provider does not support it.",
                     this.resourceForError(resource)
                 ))));
             }
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite)) {
                 throw ( new Error(( localize(
-                    1921,
+                    1922,
                     "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
                     this.resourceForError(resource)
                 ))));
             }
             if (unlock) {
                 throw ( new Error(( localize(
-                    1922,
+                    1923,
                     "Unable to unlock file '{0}' because atomic write is enabled.",
                     this.resourceForError(resource)
                 ))));
@@ -415,36 +484,46 @@ let FileService = class FileService extends Disposable {
         let stat = undefined;
         try {
             stat = await provider.stat(resource);
-        }
-        catch (error) {
+        } catch (error) {
             return Object.create(null);
         }
         if ((stat.type & FileType.Directory) !== 0) {
             throw ( new FileOperationError(( localize(
-                1923,
+                1924,
                 "Unable to write file '{0}' that is actually a directory",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_IS_DIRECTORY, options));
         }
         this.throwIfFileIsReadonly(resource, stat);
         let buffer;
-        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 })) {
+        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
+        })) {
             buffer = await this.peekBufferForWriting(provider, bufferOrReadableOrStream);
             if (buffer instanceof VSBuffer && buffer.byteLength === stat.size) {
                 try {
-                    const { value } = await this.readFile(resource, { limits: { size: stat.size } });
+                    const {
+                        value
+                    } = await this.readFile(resource, {
+                        limits: {
+                            size: stat.size
+                        }
+                    });
                     if (buffer.equals(value)) {
-                        return { stat, buffer };
+                        return {
+                            stat,
+                            buffer
+                        };
                     }
-                }
-                catch (error) {
-                }
+                } catch (error) {}
             }
-            throw ( new FileOperationError(( localize(1924, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options));
+            throw ( new FileOperationError(( localize(1925, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options));
         }
-        return { stat, buffer };
+        return {
+            stat,
+            buffer
+        };
     }
     async readFile(resource, options, token) {
         const provider = await this.withReadProvider(resource);
@@ -459,8 +538,7 @@ let FileService = class FileService extends Disposable {
                 try {
                     const content = await this.doReadFile(provider, resource, options, token);
                     resolve(content);
-                }
-                catch (error) {
+                } catch (error) {
                     reject(error);
                 }
             }, this.getExtUri(provider).providerExtUri);
@@ -484,7 +562,10 @@ let FileService = class FileService extends Disposable {
         const cancellableSource = ( new CancellationTokenSource(token));
         let readFileOptions = options;
         if (hasFileAtomicReadCapability(provider) && provider.enforceAtomicReadFile?.(resource)) {
-            readFileOptions = { ...options, atomic: true };
+            readFileOptions = {
+                ...options,
+                atomic: true
+            };
         }
         const statPromise = this.validateReadFile(resource, readFileOptions).then(stat => stat, error => {
             cancellableSource.dispose(true);
@@ -492,13 +573,11 @@ let FileService = class FileService extends Disposable {
         });
         let fileStream = undefined;
         try {
-            if (typeof readFileOptions?.etag === 'string' && readFileOptions.etag !== ETAG_DISABLED) {
+            if (typeof readFileOptions?.etag === "string" && readFileOptions.etag !== ETAG_DISABLED) {
                 await statPromise;
             }
-            if ((readFileOptions?.atomic && hasFileAtomicReadCapability(provider)) ||
-                !(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) ||
-                (hasReadWriteCapability(provider) && readFileOptions?.preferUnbuffered)
-            ) {
+            if (
+            (readFileOptions?.atomic && hasFileAtomicReadCapability(provider)) || !(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) || (hasReadWriteCapability(provider) && readFileOptions?.preferUnbuffered)) {
                 fileStream = this.readFileUnbuffered(provider, resource, readFileOptions);
             }
             else if (hasFileReadStreamCapability(provider)) {
@@ -507,15 +586,14 @@ let FileService = class FileService extends Disposable {
             else {
                 fileStream = this.readFileBuffered(provider, resource, cancellableSource.token, readFileOptions);
             }
-            fileStream.on('end', () => cancellableSource.dispose());
-            fileStream.on('error', () => cancellableSource.dispose());
+            fileStream.on("end", () => cancellableSource.dispose());
+            fileStream.on("error", () => cancellableSource.dispose());
             const fileStat = await statPromise;
             return {
                 ...fileStat,
                 value: fileStream
             };
-        }
-        catch (error) {
+        } catch (error) {
             if (fileStream) {
                 await consumeStream(fileStream);
             }
@@ -524,7 +602,7 @@ let FileService = class FileService extends Disposable {
     }
     restoreReadError(error, resource, options) {
         const message = ( localize(
-            1925,
+            1926,
             "Unable to read file '{0}' ({1})",
             this.resourceForError(resource),
             (ensureFileSystemProviderError(error).toString())
@@ -559,21 +637,21 @@ let FileService = class FileService extends Disposable {
             try {
                 let buffer;
                 if (options?.atomic && hasFileAtomicReadCapability(provider)) {
-                    buffer = await provider.readFile(resource, { atomic: true });
-                }
-                else {
+                    buffer = await provider.readFile(resource, {
+                        atomic: true
+                    });
+                } else {
                     buffer = await provider.readFile(resource);
                 }
-                if (typeof options?.position === 'number') {
+                if (typeof options?.position === "number") {
                     buffer = buffer.slice(options.position);
                 }
-                if (typeof options?.length === 'number') {
+                if (typeof options?.length === "number") {
                     buffer = buffer.slice(0, options.length);
                 }
                 this.validateReadFileLimits(resource, buffer.byteLength, options);
                 stream.end(VSBuffer.wrap(buffer));
-            }
-            catch (err) {
+            } catch (err) {
                 stream.error(err);
                 stream.end();
             }
@@ -581,43 +659,44 @@ let FileService = class FileService extends Disposable {
         return stream;
     }
     async validateReadFile(resource, options) {
-        const stat = await this.resolve(resource, { resolveMetadata: true });
+        const stat = await this.resolve(resource, {
+            resolveMetadata: true
+        });
         if (stat.isDirectory) {
             throw ( new FileOperationError(( localize(
-                1926,
+                1927,
                 "Unable to read file '{0}' that is actually a directory",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_IS_DIRECTORY, options));
         }
-        if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw ( new NotModifiedSinceFileOperationError(( localize(1927, "File not modified since")), stat, options));
+        if (typeof options?.etag === "string" && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
+            throw ( new NotModifiedSinceFileOperationError(( localize(1928, "File not modified since")), stat, options));
         }
         this.validateReadFileLimits(resource, stat.size, options);
         return stat;
     }
     validateReadFileLimits(resource, size, options) {
-        if (typeof options?.limits?.size === 'number' && size > options.limits.size) {
+        if (typeof options?.limits?.size === "number" && size > options.limits.size) {
             throw ( new TooLargeFileOperationError(( localize(
-                1928,
+                1929,
                 "Unable to read file '{0}' that is too large to open",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_TOO_LARGE, size, options));
         }
     }
     async canMove(source, target, overwrite) {
-        return this.doCanMoveCopy(source, target, 'move', overwrite);
+        return this.doCanMoveCopy(source, target, "move", overwrite);
     }
     async canCopy(source, target, overwrite) {
-        return this.doCanMoveCopy(source, target, 'copy', 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 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) {
+            } catch (error) {
                 return error;
             }
         }
@@ -626,11 +705,13 @@ let FileService = class FileService extends Disposable {
     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 });
+        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' ? FileOperation.MOVE : FileOperation.COPY,
+            mode === "move" ? FileOperation.MOVE : FileOperation.COPY,
             fileStat
         )));
         return fileStat;
@@ -638,11 +719,13 @@ let FileService = class FileService extends Disposable {
     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 });
+        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' ? FileOperation.COPY : FileOperation.MOVE,
+            mode === "copy" ? FileOperation.COPY : FileOperation.MOVE,
             fileStat
         )));
         return fileStat;
@@ -651,21 +734,30 @@ let FileService = class FileService extends Disposable {
         if (( source.toString()) === ( target.toString())) {
             return mode;
         }
-        const { exists, isSameResourceWithDifferentPathCase } = await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
+        const {
+            exists,
+            isSameResourceWithDifferentPathCase
+        } = await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
         if (exists && !isSameResourceWithDifferentPathCase && overwrite) {
-            await this.del(target, { recursive: true });
+            await this.del(target, {
+                recursive: true
+            });
         }
-        await this.mkdirp(targetProvider, this.getExtUri(targetProvider).providerExtUri.dirname(target));
-        if (mode === 'copy') {
+        await this.mkdirp(
+            targetProvider,
+            this.getExtUri(targetProvider).providerExtUri.dirname(target)
+        );
+        if (mode === "copy") {
             if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
-                await sourceProvider.copy(source, target, { overwrite });
+                await sourceProvider.copy(source, target, {
+                    overwrite
+                });
             }
             else {
                 const sourceFile = await this.resolve(source);
                 if (sourceFile.isDirectory) {
                     await this.doCopyFolder(sourceProvider, sourceFile, targetProvider, target);
-                }
-                else {
+                } else {
                     await this.doCopyFile(sourceProvider, source, targetProvider, target);
                 }
             }
@@ -673,13 +765,17 @@ let FileService = class FileService extends Disposable {
         }
         else {
             if (sourceProvider === targetProvider) {
-                await sourceProvider.rename(source, target, { overwrite });
+                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';
+                await this.doMoveCopy(sourceProvider, source, targetProvider, target, "copy", overwrite);
+                await this.del(source, {
+                    recursive: true
+                });
+                return "copy";
             }
         }
     }
@@ -700,12 +796,16 @@ let FileService = class FileService extends Disposable {
     async doCopyFolder(sourceProvider, sourceFolder, targetProvider, targetFolder) {
         await targetProvider.mkdir(targetFolder);
         if (Array.isArray(sourceFolder.children)) {
-            await Promises.settled(( sourceFolder.children.map(async (sourceChild) => {
+            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.doCopyFolder(
+                        sourceProvider,
+                        await this.resolve(sourceChild.resource),
+                        targetProvider,
+                        targetChild
+                    );
+                } else {
                     return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
                 }
             })));
@@ -714,13 +814,16 @@ let FileService = class FileService extends Disposable {
     async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
         let isSameResourceWithDifferentPathCase = false;
         if (sourceProvider === targetProvider) {
-            const { providerExtUri, isPathCaseSensitive } = this.getExtUri(sourceProvider);
+            const {
+                providerExtUri,
+                isPathCaseSensitive
+            } = this.getExtUri(sourceProvider);
             if (!isPathCaseSensitive) {
                 isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
             }
-            if (isSameResourceWithDifferentPathCase && mode === 'copy') {
+            if (isSameResourceWithDifferentPathCase && mode === "copy") {
                 throw ( new Error(( localize(
-                    1929,
+                    1930,
                     "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)
@@ -728,7 +831,7 @@ let FileService = class FileService extends Disposable {
             }
             if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
                 throw ( new Error(( localize(
-                    1930,
+                    1931,
                     "Unable to move/copy when source '{0}' is parent of target '{1}'.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -739,17 +842,19 @@ let FileService = class FileService extends Disposable {
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
                 throw ( new FileOperationError(( localize(
-                    1931,
+                    1932,
                     "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
                     this.resourceForError(source),
                     this.resourceForError(target)
                 )), FileOperationResult.FILE_MOVE_CONFLICT));
             }
             if (sourceProvider === targetProvider) {
-                const { providerExtUri } = this.getExtUri(sourceProvider);
+                const {
+                    providerExtUri
+                } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
                     throw ( new Error(( localize(
-                        1932,
+                        1933,
                         "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.",
                         this.resourceForError(source),
                         this.resourceForError(target)
@@ -757,7 +862,10 @@ let FileService = class FileService extends Disposable {
                 }
             }
         }
-        return { exists, isSameResourceWithDifferentPathCase };
+        return {
+            exists,
+            isSameResourceWithDifferentPathCase
+        };
     }
     getExtUri(provider) {
         const isPathCaseSensitive = this.isPathCaseSensitive(provider);
@@ -772,19 +880,22 @@ let FileService = class FileService extends Disposable {
     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 });
+        const fileStat = await this.resolve(resource, {
+            resolveMetadata: true
+        });
         this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.CREATE, fileStat)));
         return fileStat;
     }
     async mkdirp(provider, directory) {
-        const { providerExtUri } = this.getExtUri(provider);
+        const {
+            providerExtUri
+        } = this.getExtUri(provider);
         return mkdirp(providerExtUri, provider, directory);
     }
     async canDelete(resource, options) {
         try {
             await this.doValidateDelete(resource, options);
-        }
-        catch (error) {
+        } catch (error) {
             return error;
         }
         return true;
@@ -794,7 +905,7 @@ let FileService = class FileService extends Disposable {
         const useTrash = !!options?.useTrash;
         if (useTrash && !(provider.capabilities & FileSystemProviderCapabilities.Trash)) {
             throw ( new Error(( localize(
-                1933,
+                1934,
                 "Unable to delete file '{0}' via trash because provider does not support it.",
                 this.resourceForError(resource)
             ))));
@@ -802,14 +913,14 @@ let FileService = class FileService extends Disposable {
         const atomic = options?.atomic;
         if (atomic && !(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete)) {
             throw ( new Error(( localize(
-                1934,
+                1935,
                 "Unable to delete file '{0}' atomically because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (useTrash && atomic) {
             throw ( new Error(( localize(
-                1935,
+                1936,
                 "Unable to atomically delete file '{0}' because using trash is enabled.",
                 this.resourceForError(resource)
             ))));
@@ -817,15 +928,12 @@ let FileService = class FileService extends Disposable {
         let stat = undefined;
         try {
             stat = await provider.stat(resource);
-        }
-        catch (error) {
-        }
+        } catch (error) {}
         if (stat) {
             this.throwIfFileIsReadonly(resource, stat);
-        }
-        else {
+        } else {
             throw ( new FileOperationError(( localize(
-                1936,
+                1937,
                 "Unable to delete nonexistent file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_NOT_FOUND));
@@ -835,7 +943,7 @@ let FileService = class FileService extends Disposable {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
                 throw ( new Error(( localize(
-                    1937,
+                    1938,
                     "Unable to delete non-empty folder '{0}'.",
                     this.resourceForError(resource)
                 ))));
@@ -849,13 +957,20 @@ let FileService = class FileService extends Disposable {
         if (hasFileAtomicDeleteCapability(provider) && !deleteFileOptions?.atomic) {
             const enforcedAtomicDelete = provider.enforceAtomicDelete?.(resource);
             if (enforcedAtomicDelete) {
-                deleteFileOptions = { ...options, atomic: enforcedAtomicDelete };
+                deleteFileOptions = {
+                    ...options,
+                    atomic: enforcedAtomicDelete
+                };
             }
         }
         const useTrash = !!deleteFileOptions?.useTrash;
         const recursive = !!deleteFileOptions?.recursive;
         const atomic = deleteFileOptions?.atomic ?? false;
-        await provider.delete(resource, { recursive, useTrash, atomic });
+        await provider.delete(resource, {
+            recursive,
+            useTrash,
+            atomic
+        });
         this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.DELETE)));
     }
     async cloneFile(source, target) {
@@ -867,40 +982,57 @@ let FileService = class FileService extends Disposable {
         if (sourceProvider === targetProvider && hasFileCloneCapability(sourceProvider)) {
             return sourceProvider.cloneFile(source, target);
         }
-        await this.mkdirp(targetProvider, this.getExtUri(targetProvider).providerExtUri.dirname(target));
+        await this.mkdirp(
+            targetProvider,
+            this.getExtUri(targetProvider).providerExtUri.dirname(target)
+        );
         if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
-            return this.writeQueue.queueFor(source, () => sourceProvider.copy(source, target, { overwrite: true }), this.getExtUri(sourceProvider).providerExtUri);
+            return this.writeQueue.queueFor(source, () => sourceProvider.copy(source, target, {
+                overwrite: true
+            }), this.getExtUri(sourceProvider).providerExtUri);
         }
-        return this.writeQueue.queueFor(source, () => this.doCopyFile(sourceProvider, source, targetProvider, target), this.getExtUri(sourceProvider).providerExtUri);
+        return this.writeQueue.queueFor(
+            source,
+            () => this.doCopyFile(sourceProvider, source, targetProvider, target),
+            this.getExtUri(sourceProvider).providerExtUri
+        );
+    }
+    static {
+        this.WATCHER_CORRELATION_IDS = 0;
     }
-    static { this.WATCHER_CORRELATION_IDS = 0; }
     createWatcher(resource, options) {
         return this.watch(resource, {
             ...options,
             correlationId: FileService_1.WATCHER_CORRELATION_IDS++
         });
     }
-    watch(resource, options = { recursive: false, excludes: [] }) {
+    watch(
+        resource,
+        options = {
+            recursive: false,
+            excludes: []
+        }
+    ) {
         const disposables = ( new DisposableStore());
         let watchDisposed = false;
-        let disposeWatch = () => { watchDisposed = true; };
+        let disposeWatch = () => {
+            watchDisposed = true;
+        };
         disposables.add(toDisposable(() => disposeWatch()));
         (async () => {
             try {
                 const disposable = await this.doWatch(resource, options);
                 if (watchDisposed) {
                     dispose(disposable);
-                }
-                else {
+                } else {
                     disposeWatch = () => dispose(disposable);
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(error);
             }
         })();
         const correlationId = options.correlationId;
-        if (typeof correlationId === 'number') {
+        if (typeof correlationId === "number") {
             const fileChangeEmitter = disposables.add(( new Emitter()));
             disposables.add(this.internalOnDidFilesChange.event(e => {
                 if (e.correlates(correlationId)) {
@@ -917,7 +1049,10 @@ let FileService = class FileService extends Disposable {
     }
     async doWatch(resource, options) {
         const provider = await this.withProvider(resource);
-        const watchHash = hash([this.getExtUri(provider).providerExtUri.getComparisonKey(resource), options]);
+        const watchHash = hash([
+            this.getExtUri(provider).providerExtUri.getComparisonKey(resource),
+            options
+        ]);
         let watcher = this.activeWatchers.get(watchHash);
         if (!watcher) {
             watcher = {
@@ -946,19 +1081,20 @@ let FileService = class FileService extends Disposable {
     }
     async doWriteBuffered(provider, resource, options, readableOrStreamOrBufferedStream) {
         return this.writeQueue.queueFor(resource, async () => {
-            const handle = await provider.open(resource, { create: true, unlock: options?.unlock ?? false });
+            const handle = await provider.open(resource, {
+                create: true,
+                unlock: options?.unlock ?? false,
+                append: options?.append ?? false
+            });
             try {
                 if (isReadableStream(readableOrStreamOrBufferedStream) || isReadableBufferedStream(readableOrStreamOrBufferedStream)) {
                     await this.doWriteStreamBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
-                }
-                else {
+                } else {
                     await this.doWriteReadableBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 throw ensureFileSystemProviderError(error);
-            }
-            finally {
+            } finally {
                 await provider.close(handle);
             }
         }, this.getExtUri(provider).providerExtUri);
@@ -982,12 +1118,11 @@ let FileService = class FileService extends Disposable {
         }
         return ( new Promise((resolve, reject) => {
             listenStream(stream, {
-                onData: async (chunk) => {
+                onData: async chunk => {
                     stream.pause();
                     try {
                         await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
-                    }
-                    catch (error) {
+                    } catch (error) {
                         return reject(error);
                     }
                     posInFile += chunk.byteLength;
@@ -1009,44 +1144,72 @@ let FileService = class FileService extends Disposable {
     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);
+            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.doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream), this.getExtUri(provider).providerExtUri);
+        return this.writeQueue.queueFor(
+            resource,
+            () => this.doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream),
+            this.getExtUri(provider).providerExtUri
+        );
     }
     async doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream) {
         let buffer;
         if (bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) {
             buffer = bufferOrReadableOrStreamOrBufferedStream;
-        }
-        else if (isReadableStream(bufferOrReadableOrStreamOrBufferedStream)) {
+        } else if (isReadableStream(bufferOrReadableOrStreamOrBufferedStream)) {
             buffer = await streamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
-        }
-        else if (isReadableBufferedStream(bufferOrReadableOrStreamOrBufferedStream)) {
+        } else if (isReadableBufferedStream(bufferOrReadableOrStreamOrBufferedStream)) {
             buffer = await bufferedStreamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
-        }
-        else {
+        } else {
             buffer = readableToBuffer(bufferOrReadableOrStreamOrBufferedStream);
         }
-        await provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true, unlock: options?.unlock ?? false, atomic: options?.atomic ?? false });
+        await provider.writeFile(resource, buffer.buffer, {
+            create: true,
+            overwrite: true,
+            unlock: options?.unlock ?? false,
+            atomic: options?.atomic ?? false,
+            append: options?.append ?? false
+        });
     }
     async doPipeBuffered(sourceProvider, source, targetProvider, target) {
-        return this.writeQueue.queueFor(target, () => this.doPipeBufferedQueued(sourceProvider, source, targetProvider, target), this.getExtUri(targetProvider).providerExtUri);
+        return this.writeQueue.queueFor(
+            target,
+            () => this.doPipeBufferedQueued(sourceProvider, source, targetProvider, target),
+            this.getExtUri(targetProvider).providerExtUri
+        );
     }
     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 });
+            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);
+                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;
@@ -1054,36 +1217,55 @@ let FileService = class FileService extends Disposable {
                     posInBuffer = 0;
                 }
             } while (bytesRead > 0);
-        }
-        catch (error) {
+        } catch (error) {
             throw ensureFileSystemProviderError(error);
-        }
-        finally {
+        } finally {
             await Promises.settled([
-                typeof sourceHandle === 'number' ? sourceProvider.close(sourceHandle) : Promise.resolve(),
-                typeof targetHandle === 'number' ? targetProvider.close(targetHandle) : Promise.resolve(),
+                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.doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target), this.getExtUri(targetProvider).providerExtUri);
+        return this.writeQueue.queueFor(
+            target,
+            () => this.doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target),
+            this.getExtUri(targetProvider).providerExtUri
+        );
     }
     async doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target) {
-        return targetProvider.writeFile(target, await sourceProvider.readFile(source), { create: true, overwrite: true, unlock: false, atomic: false });
+        return targetProvider.writeFile(target, await sourceProvider.readFile(source), {
+            create: true,
+            overwrite: true,
+            unlock: false,
+            atomic: false
+        });
     }
     async doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target) {
-        return this.writeQueue.queueFor(target, () => this.doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target), this.getExtUri(targetProvider).providerExtUri);
+        return this.writeQueue.queueFor(
+            target,
+            () => this.doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target),
+            this.getExtUri(targetProvider).providerExtUri
+        );
     }
     async doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target) {
-        const targetHandle = await targetProvider.open(target, { create: true, unlock: false });
+        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) {
+            await this.doWriteBuffer(
+                targetProvider,
+                targetHandle,
+                VSBuffer.wrap(buffer),
+                buffer.byteLength,
+                0,
+                0
+            );
+        } catch (error) {
             throw ensureFileSystemProviderError(error);
-        }
-        finally {
+        } finally {
             await targetProvider.close(targetHandle);
         }
     }
@@ -1094,7 +1276,7 @@ let FileService = class FileService extends Disposable {
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & FileSystemProviderCapabilities.Readonly) {
             throw ( new FileOperationError(( localize(
-                1938,
+                1939,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_PERMISSION_DENIED));
@@ -1104,7 +1286,7 @@ let FileService = class FileService extends Disposable {
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
             throw ( new FileOperationError(( localize(
-                1938,
+                1939,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_PERMISSION_DENIED));
@@ -1114,8 +1296,6 @@ let FileService = class FileService extends Disposable {
         return resourceForError(resource);
     }
 };
-FileService = FileService_1 = ( __decorate([
-    ( __param(0, ILogService))
-], FileService));
+FileService = FileService_1 = ( __decorate([( __param(0, ILogService))], FileService));
 
 export { FileService, mkdirp };