@codingame/monaco-vscode-files-service-override 11.1.2 → 12.0.0

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
 import { VSBuffer, bufferToReadable, streamToBuffer, newWriteableBufferStream, bufferedStreamToBuffer, readableToBuffer } from 'vscode/vscode/vs/base/common/buffer';
@@ -13,7 +14,7 @@ import { mark } from 'vscode/vscode/vs/base/common/performance';
 import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'vscode/vscode/vs/base/common/resources';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from 'vscode/vscode/vs/base/common/stream';
 import { localize } from 'vscode/vscode/vs/nls';
-import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, FilePermission, etag, FileOperationEvent, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, FileOperationResult, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, FilePermission, FileSystemProviderCapabilities, etag, FileOperationEvent, FileOperation, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'vscode/vscode/vs/platform/files/common/files';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
@@ -23,9 +24,7 @@ function resourceForError(resource) {
     if (resource.scheme === Schemas.file) {
         return resource.fsPath;
     }
-    return (
-         (resource.toString(true))
-    );
+    return ( resource.toString(true));
 }
 async function mkdirp(providerExtUri, provider, directory) {
     const directoriesToCreate = [];
@@ -33,8 +32,8 @@ async function mkdirp(providerExtUri, provider, directory) {
         try {
             const stat = await provider.stat(directory);
             if ((stat.type & FileType.Directory) === 0) {
-                throw ( (new Error(localize(
-                    589,
+                throw ( new Error(( localize(
+                    1747,
                     "Unable to create folder '{0}' that already exists but is not a directory",
                     resourceForError(directory)
                 ))));
@@ -67,40 +66,40 @@ let FileService = class FileService extends Disposable {
         super();
         this.logService = logService;
         this.BUFFER_SIZE = 256 * 1024;
-        this._onDidChangeFileSystemProviderRegistrations = this._register(( (new Emitter())));
+        this._onDidChangeFileSystemProviderRegistrations = this._register(( new Emitter()));
         this.onDidChangeFileSystemProviderRegistrations = this._onDidChangeFileSystemProviderRegistrations.event;
-        this._onWillActivateFileSystemProvider = this._register(( (new Emitter())));
+        this._onWillActivateFileSystemProvider = this._register(( new Emitter()));
         this.onWillActivateFileSystemProvider = this._onWillActivateFileSystemProvider.event;
-        this._onDidChangeFileSystemProviderCapabilities = this._register(( (new Emitter())));
+        this._onDidChangeFileSystemProviderCapabilities = this._register(( new Emitter()));
         this.onDidChangeFileSystemProviderCapabilities = this._onDidChangeFileSystemProviderCapabilities.event;
-        this.provider = ( (new Map()));
-        this._onDidRunOperation = this._register(( (new Emitter())));
+        this.provider = ( new Map());
+        this._onDidRunOperation = this._register(( new Emitter()));
         this.onDidRunOperation = this._onDidRunOperation.event;
-        this.internalOnDidFilesChange = this._register(( (new Emitter())));
-        this._onDidUncorrelatedFilesChange = this._register(( (new Emitter())));
+        this.internalOnDidFilesChange = this._register(( new Emitter()));
+        this._onDidUncorrelatedFilesChange = this._register(( new Emitter()));
         this.onDidFilesChange = this._onDidUncorrelatedFilesChange.event;
-        this._onDidWatchError = this._register(( (new Emitter())));
+        this._onDidWatchError = this._register(( new Emitter()));
         this.onDidWatchError = this._onDidWatchError.event;
-        this.activeWatchers = ( (new Map()));
-        this.writeQueue = this._register(( (new ResourceQueue())));
+        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.`)));
+        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()));
+        const providerDisposables = ( new DisposableStore());
         this.provider.set(scheme, provider);
         this._onDidChangeFileSystemProviderRegistrations.fire({ added: true, scheme, provider });
         providerDisposables.add(provider.onDidChangeFile(changes => {
-            const event = ( (new FileChangesEvent(changes, !this.isPathCaseSensitive(provider))));
+            const event = ( new FileChangesEvent(changes, !this.isPathCaseSensitive(provider)));
             this.internalOnDidFilesChange.fire(event);
             if (!event.hasCorrelation()) {
                 this._onDidUncorrelatedFilesChange.fire(event);
             }
         }));
         if (typeof provider.onDidWatchError === 'function') {
-            providerDisposables.add(provider.onDidWatchError(error => this._onDidWatchError.fire(( (new Error(error))))));
+            providerDisposables.add(provider.onDidWatchError(error => this._onDidWatchError.fire(( new Error(error)))));
         }
         providerDisposables.add(provider.onDidChangeCapabilities(() => this._onDidChangeFileSystemProviderCapabilities.fire({ provider, scheme })));
         return toDisposable(() => {
@@ -120,7 +119,7 @@ let FileService = class FileService extends Disposable {
                 joiners.push(promise);
             },
         });
-        if (( (this.provider.has(scheme)))) {
+        if (( this.provider.has(scheme))) {
             return;
         }
         await Promises.settled(joiners);
@@ -130,38 +129,34 @@ let FileService = class FileService extends Disposable {
         return this.hasProvider(resource);
     }
     hasProvider(resource) {
-        return (
-             (this.provider.has(resource.scheme))
-        );
+        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 })
-            ))
-        );
+        return ( Iterable.map(
+            this.provider,
+            ([scheme, provider]) => ({ scheme, capabilities: provider.capabilities })
+        ));
     }
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
-            throw ( (new FileOperationError(localize(
-                590,
+            throw ( new FileOperationError(( localize(
+                1748,
                 "Unable to resolve filesystem provider with relative file path '{0}'",
                 this.resourceForError(resource)
-            ), 8 )));
+            )), FileOperationResult.FILE_INVALID_PATH));
         }
         await this.activateProvider(resource.scheme);
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
-            const error = ( (new ErrorNoTelemetry()));
+            const error = ( new ErrorNoTelemetry());
             error.message = ( localize(
-                591,
+                1749,
                 "ENOPRO: No file system provider found for resource '{0}'",
-                 (resource.toString())
+                (resource.toString())
             ));
             throw error;
         }
@@ -172,18 +167,18 @@ let FileService = class FileService extends Disposable {
         if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider)) {
             return provider;
         }
-        throw ( (new Error(
+        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(
+        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 {
@@ -191,11 +186,11 @@ let FileService = class FileService extends Disposable {
         }
         catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
-                throw ( (new FileOperationError(localize(
-                    592,
+                throw ( new FileOperationError(( localize(
+                    1750,
                     "Unable to resolve nonexistent file '{0}'",
                     this.resourceForError(resource)
-                ), 1 )));
+                )), FileOperationResult.FILE_NOT_FOUND));
             }
             throw ensureFileSystemProviderError(error);
         }
@@ -236,7 +231,7 @@ let FileService = class FileService extends Disposable {
             mtime: stat.mtime,
             ctime: stat.ctime,
             size: stat.size,
-            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & 2048 ),
+            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & FileSystemProviderCapabilities.Readonly),
             locked: Boolean((stat.permissions ?? 0) & FilePermission.Locked),
             etag: etag({ mtime: stat.mtime, size: stat.size }),
             children: undefined
@@ -244,7 +239,7 @@ let FileService = class FileService extends Disposable {
         if (fileStat.isDirectory && recurse(fileStat, siblings)) {
             try {
                 const entries = await provider.readdir(resource);
-                const resolvedEntries = await Promises.settled(( (entries.map(async ([name, type]) => {
+                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 };
@@ -254,7 +249,7 @@ let FileService = class FileService extends Disposable {
                         this.logService.trace(error);
                         return null;
                     }
-                }))));
+                })));
                 fileStat.children = coalesce(resolvedEntries);
             }
             catch (error) {
@@ -266,7 +261,7 @@ 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 };
             }
@@ -274,7 +269,7 @@ let FileService = class FileService extends Disposable {
                 this.logService.trace(error);
                 return { stat: undefined, success: false };
             }
-        }))));
+        })));
     }
     async stat(resource) {
         const provider = await this.withProvider(resource);
@@ -302,17 +297,17 @@ let FileService = class FileService extends Disposable {
     }
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
-            throw ( (new FileOperationError(localize(
-                593,
+            throw ( new FileOperationError(( localize(
+                1751,
                 "Unable to create file '{0}' that already exists when overwrite flag is not set",
                 this.resourceForError(resource)
-            ), 3 , options)));
+            )), FileOperationResult.FILE_MODIFIED_SINCE, 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))));
+        this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.CREATE, fileStat)));
         return fileStat;
     }
     async writeFile(resource, bufferOrReadableOrStream, options) {
@@ -357,46 +352,46 @@ let FileService = class FileService extends Disposable {
             else {
                 await this.doWriteBuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
             }
-            this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 4 ))));
+            this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.WRITE)));
         }
         catch (error) {
-            throw ( (new FileOperationError(localize(
-                594,
+            throw ( new FileOperationError(( localize(
+                1752,
                 "Unable to write file '{0}' ({1})",
                 this.resourceForError(resource),
-                ( (ensureFileSystemProviderError(error).toString()))
-            ), toFileOperationResult(error), writeFileOptions)));
+                (ensureFileSystemProviderError(error).toString())
+            )), toFileOperationResult(error), writeFileOptions));
         }
         return this.resolve(resource, { resolveMetadata: true });
     }
     async validateWriteFile(provider, resource, options) {
         const unlock = !!options?.unlock;
-        if (unlock && !((provider.capabilities & 8192) )) {
-            throw ( (new Error(localize(
-                595,
+        if (unlock && !(provider.capabilities & FileSystemProviderCapabilities.FileWriteUnlock)) {
+            throw ( new Error(( localize(
+                1753,
                 "Unable to unlock file '{0}' because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         const atomic = !!options?.atomic;
         if (atomic) {
-            if (!((provider.capabilities & 32768) )) {
-                throw ( (new Error(localize(
-                    596,
+            if (!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite)) {
+                throw ( new Error(( localize(
+                    1754,
                     "Unable to atomically write file '{0}' because provider does not support it.",
                     this.resourceForError(resource)
                 ))));
             }
-            if (!((provider.capabilities & 2) )) {
-                throw ( (new Error(localize(
-                    597,
+            if (!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite)) {
+                throw ( new Error(( localize(
+                    1755,
                     "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
                     this.resourceForError(resource)
                 ))));
             }
             if (unlock) {
-                throw ( (new Error(localize(
-                    598,
+                throw ( new Error(( localize(
+                    1756,
                     "Unable to unlock file '{0}' because atomic write is enabled.",
                     this.resourceForError(resource)
                 ))));
@@ -410,21 +405,17 @@ let FileService = class FileService extends Disposable {
             return undefined;
         }
         if ((stat.type & FileType.Directory) !== 0) {
-            throw ( (new FileOperationError(localize(
-                599,
+            throw ( new FileOperationError(( localize(
+                1757,
                 "Unable to write file '{0}' that is actually a directory",
                 this.resourceForError(resource)
-            ), 0 , options)));
+            )), FileOperationResult.FILE_IS_DIRECTORY, 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(600, "File Modified Since"),
-                3 ,
-                options
-            )));
+            throw ( new FileOperationError(( localize(1758, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options));
         }
         return stat;
     }
@@ -436,19 +427,17 @@ let FileService = class FileService extends Disposable {
         return this.doReadFile(provider, resource, options, token);
     }
     async doReadFileAtomic(provider, resource, options, token) {
-        return (
-             (new Promise((resolve, reject) => {
-                this.writeQueue.queueFor(resource, async () => {
-                    try {
-                        const content = await this.doReadFile(provider, resource, options, token);
-                        resolve(content);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                }, this.getExtUri(provider).providerExtUri);
-            }))
-        );
+        return ( new Promise((resolve, reject) => {
+            this.writeQueue.queueFor(resource, async () => {
+                try {
+                    const content = await this.doReadFile(provider, resource, options, token);
+                    resolve(content);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, this.getExtUri(provider).providerExtUri);
+        }));
     }
     async doReadFile(provider, resource, options, token) {
         const stream = await this.doReadFileStream(provider, resource, {
@@ -465,7 +454,7 @@ let FileService = class FileService extends Disposable {
         return this.doReadFileStream(provider, resource, options, token);
     }
     async doReadFileStream(provider, resource, options, token) {
-        const cancellableSource = ( (new CancellationTokenSource(token)));
+        const cancellableSource = ( new CancellationTokenSource(token));
         let readFileOptions = options;
         if (hasFileAtomicReadCapability(provider) && provider.enforceAtomicReadFile?.(resource)) {
             readFileOptions = { ...options, atomic: true };
@@ -508,24 +497,18 @@ let FileService = class FileService extends Disposable {
     }
     restoreReadError(error, resource, options) {
         const message = ( localize(
-            601,
+            1759,
             "Unable to read file '{0}' ({1})",
             this.resourceForError(resource),
-             (ensureFileSystemProviderError(error).toString())
+            (ensureFileSystemProviderError(error).toString())
         ));
         if (error instanceof NotModifiedSinceFileOperationError) {
-            return (
-                 (new NotModifiedSinceFileOperationError(message, error.stat, options))
-            );
+            return ( new NotModifiedSinceFileOperationError(message, error.stat, options));
         }
         if (error instanceof TooLargeFileOperationError) {
-            return (
-                 (new TooLargeFileOperationError(message, error.fileOperationResult, error.size, error.options))
-            );
+            return ( new TooLargeFileOperationError(message, error.fileOperationResult, error.size, error.options));
         }
-        return (
-             (new FileOperationError(message, toFileOperationResult(error), options))
-        );
+        return ( new FileOperationError(message, toFileOperationResult(error), options));
     }
     readFileStreamed(provider, resource, token, options = Object.create(null)) {
         const fileStream = provider.readFileStream(resource, options, token);
@@ -573,25 +556,25 @@ let FileService = class FileService extends Disposable {
     async validateReadFile(resource, options) {
         const stat = await this.resolve(resource, { resolveMetadata: true });
         if (stat.isDirectory) {
-            throw ( (new FileOperationError(localize(
-                602,
+            throw ( new FileOperationError(( localize(
+                1760,
                 "Unable to read file '{0}' that is actually a directory",
                 this.resourceForError(resource)
-            ), 0 , options)));
+            )), FileOperationResult.FILE_IS_DIRECTORY, options));
         }
         if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw ( (new NotModifiedSinceFileOperationError(localize(603, "File not modified since"), stat, options)));
+            throw ( new NotModifiedSinceFileOperationError(( localize(1761, "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) {
-            throw ( (new TooLargeFileOperationError(localize(
-                604,
+            throw ( new TooLargeFileOperationError(( localize(
+                1762,
                 "Unable to read file '{0}' that is too large to open",
                 this.resourceForError(resource)
-            ), 7 , size, options)));
+            )), FileOperationResult.FILE_TOO_LARGE, size, options));
         }
     }
     async canMove(source, target, overwrite) {
@@ -601,7 +584,7 @@ let FileService = class FileService extends Disposable {
         return this.doCanMoveCopy(source, target, 'copy', overwrite);
     }
     async doCanMoveCopy(source, target, mode, overwrite) {
-        if (( (source.toString())) !== ( (target.toString()))) {
+        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);
@@ -618,11 +601,11 @@ let FileService = class FileService extends Disposable {
         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(
+        this._onDidRunOperation.fire(( new FileOperationEvent(
             source,
-            mode === 'move' ? 2  : 3 ,
+            mode === 'move' ? FileOperation.MOVE : FileOperation.COPY,
             fileStat
-        ))));
+        )));
         return fileStat;
     }
     async copy(source, target, overwrite) {
@@ -630,15 +613,15 @@ let FileService = class FileService extends Disposable {
         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(
+        this._onDidRunOperation.fire(( new FileOperationEvent(
             source,
-            mode === 'copy' ? 3  : 2 ,
+            mode === 'copy' ? FileOperation.COPY : FileOperation.MOVE,
             fileStat
-        ))));
+        )));
         return fileStat;
     }
     async doMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
-        if (( (source.toString())) === ( (target.toString()))) {
+        if (( source.toString()) === ( target.toString())) {
             return mode;
         }
         const { exists, isSameResourceWithDifferentPathCase } = await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
@@ -690,7 +673,7 @@ 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);
@@ -698,7 +681,7 @@ let FileService = class FileService extends Disposable {
                 else {
                     return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
                 }
-            }))));
+            })));
         }
     }
     async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
@@ -709,16 +692,16 @@ let FileService = class FileService extends Disposable {
                 isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw ( (new Error(localize(
-                    605,
+                throw ( new Error(( localize(
+                    1763,
                     "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(
-                    606,
+                throw ( new Error(( localize(
+                    1764,
                     "Unable to move/copy when source '{0}' is parent of target '{1}'.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -728,18 +711,18 @@ let FileService = class FileService extends Disposable {
         const exists = await this.exists(target);
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
-                throw ( (new FileOperationError(localize(
-                    607,
+                throw ( new FileOperationError(( localize(
+                    1765,
                     "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
                     this.resourceForError(source),
                     this.resourceForError(target)
-                ), 4 )));
+                )), FileOperationResult.FILE_MOVE_CONFLICT));
             }
             if (sourceProvider === targetProvider) {
                 const { providerExtUri } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
-                    throw ( (new Error(localize(
-                        608,
+                    throw ( new Error(( localize(
+                        1766,
                         "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,13 +740,13 @@ let FileService = class FileService extends Disposable {
         };
     }
     isPathCaseSensitive(provider) {
-        return !!((provider.capabilities & 1024) );
+        return !!(provider.capabilities & FileSystemProviderCapabilities.PathCaseSensitive);
     }
     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))));
+        this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.CREATE, fileStat)));
         return fileStat;
     }
     async mkdirp(provider, directory) {
@@ -782,24 +765,24 @@ let FileService = class FileService extends Disposable {
     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(
-                609,
+        if (useTrash && !(provider.capabilities & FileSystemProviderCapabilities.Trash)) {
+            throw ( new Error(( localize(
+                1767,
                 "Unable to delete file '{0}' via trash because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         const atomic = options?.atomic;
-        if (atomic && !((provider.capabilities & 65536) )) {
-            throw ( (new Error(localize(
-                610,
+        if (atomic && !(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete)) {
+            throw ( new Error(( localize(
+                1768,
                 "Unable to delete file '{0}' atomically because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (useTrash && atomic) {
-            throw ( (new Error(localize(
-                611,
+            throw ( new Error(( localize(
+                1769,
                 "Unable to atomically delete file '{0}' because using trash is enabled.",
                 this.resourceForError(resource)
             ))));
@@ -814,18 +797,18 @@ let FileService = class FileService extends Disposable {
             this.throwIfFileIsReadonly(resource, stat);
         }
         else {
-            throw ( (new FileOperationError(localize(
-                612,
+            throw ( new FileOperationError(( localize(
+                1770,
                 "Unable to delete nonexistent file '{0}'",
                 this.resourceForError(resource)
-            ), 1 )));
+            )), FileOperationResult.FILE_NOT_FOUND));
         }
         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(
-                    613,
+                throw ( new Error(( localize(
+                    1771,
                     "Unable to delete non-empty folder '{0}'.",
                     this.resourceForError(resource)
                 ))));
@@ -846,7 +829,7 @@ let FileService = class FileService extends Disposable {
         const recursive = !!deleteFileOptions?.recursive;
         const atomic = deleteFileOptions?.atomic ?? false;
         await provider.delete(resource, { recursive, useTrash, atomic });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 1 ))));
+        this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.DELETE)));
     }
     async cloneFile(source, target) {
         const sourceProvider = await this.withProvider(source);
@@ -871,7 +854,7 @@ let FileService = class FileService extends Disposable {
         });
     }
     watch(resource, options = { recursive: false, excludes: [] }) {
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         let watchDisposed = false;
         let disposeWatch = () => { watchDisposed = true; };
         disposables.add(toDisposable(() => disposeWatch()));
@@ -891,7 +874,7 @@ let FileService = class FileService extends Disposable {
         })();
         const correlationId = options.correlationId;
         if (typeof correlationId === 'number') {
-            const fileChangeEmitter = disposables.add(( (new Emitter())));
+            const fileChangeEmitter = disposables.add(( new Emitter()));
             disposables.add(this.internalOnDidFilesChange.event(e => {
                 if (e.correlates(correlationId)) {
                     fileChangeEmitter.fire(e);
@@ -970,25 +953,23 @@ let FileService = class FileService extends Disposable {
         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()
-                });
-            }))
-        );
+        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;
@@ -1084,30 +1065,30 @@ let FileService = class FileService extends Disposable {
         await this.doWriteUnbuffered(targetProvider, target, undefined, buffer);
     }
     throwIfFileSystemIsReadonly(provider, resource) {
-        if (provider.capabilities & 2048 ) {
-            throw ( (new FileOperationError(localize(
-                614,
+        if (provider.capabilities & FileSystemProviderCapabilities.Readonly) {
+            throw ( new FileOperationError(( localize(
+                1772,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
-            ), 6 )));
+            )), FileOperationResult.FILE_PERMISSION_DENIED));
         }
         return provider;
     }
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
-            throw ( (new FileOperationError(localize(
-                614,
+            throw ( new FileOperationError(( localize(
+                1772,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
-            ), 6 )));
+            )), FileOperationResult.FILE_PERMISSION_DENIED));
         }
     }
     resourceForError(resource) {
         return resourceForError(resource);
     }
 };
-FileService = FileService_1 = ( (__decorate([
-    ( (__param(0, ILogService)))
-], FileService)));
+FileService = FileService_1 = ( __decorate([
+    ( __param(0, ILogService))
+], FileService));
 
 export { FileService, mkdirp };