@codingame/monaco-vscode-files-service-override 4.5.0 → 4.5.2

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

@@ -13,52 +13,96 @@ 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 { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, ensureFileSystemProviderError, FileType, 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, 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 { readFileIntoStream } from './io.js';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
 var FileService_1;
+const _moduleId = "vs/platform/files/common/fileService";
+function resourceForError(resource) {
+    if (resource.scheme === Schemas.file) {
+        return resource.fsPath;
+    }
+    return (
+         (resource.toString(true))
+    );
+}
+async function mkdirp(providerExtUri, provider, directory) {
+    const directoriesToCreate = [];
+    while (!providerExtUri.isEqual(directory, providerExtUri.dirname(directory))) {
+        try {
+            const stat = await provider.stat(directory);
+            if ((stat.type & FileType.Directory) === 0) {
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    0,
+                    "Unable to create folder '{0}' that already exists but is not a directory",
+                    resourceForError(directory)
+                ))));
+            }
+            break;
+        }
+        catch (error) {
+            if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
+                throw error;
+            }
+            directoriesToCreate.push(providerExtUri.basename(directory));
+            directory = providerExtUri.dirname(directory);
+        }
+    }
+    for (let i = directoriesToCreate.length - 1; i >= 0; i--) {
+        directory = providerExtUri.joinPath(directory, directoriesToCreate[i]);
+        try {
+            await provider.mkdir(directory);
+        }
+        catch (error) {
+            if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
+                throw error;
+            }
+        }
+    }
+}
 let FileService = class FileService extends Disposable {
     static { FileService_1 = this; }
     constructor(logService) {
         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(() => {
@@ -78,7 +122,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);
@@ -88,31 +132,40 @@ 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(localizeWithPath('vs/platform/files/common/fileService', 'invalidPath', "Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 );
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                1,
+                "Unable to resolve filesystem provider with relative file path '{0}'",
+                this.resourceForError(resource)
+            ), 8 )));
         }
         await this.activateProvider(resource.scheme);
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
-            const error = ( new ErrorNoTelemetry());
+            const error = ( (new ErrorNoTelemetry()));
             error.message = ( localizeWithPath(
-                'vs/platform/files/common/fileService',
-                'noProviderFound',
+                _moduleId,
+                2,
                 "ENOPRO: No file system provider found for resource '{0}'",
-                ( resource.toString())
+                 (resource.toString())
             ));
             throw error;
         }
@@ -123,14 +176,18 @@ let FileService = class FileService extends Disposable {
         if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider)) {
             return provider;
         }
-        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`);
+        throw ( (new Error(
+            `Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`
+        )));
     }
     async withWriteProvider(resource) {
         const provider = await this.withProvider(resource);
         if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider)) {
             return provider;
         }
-        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite nor FileOpenReadWriteClose capability which is needed for the write operation.`);
+        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 {
@@ -138,7 +195,12 @@ let FileService = class FileService extends Disposable {
         }
         catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
-                throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileNotFoundError', "Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+                throw ( (new FileOperationError(localizeWithPath(
+                    _moduleId,
+                    3,
+                    "Unable to resolve nonexistent file '{0}'",
+                    this.resourceForError(resource)
+                ), 1 )));
             }
             throw ensureFileSystemProviderError(error);
         }
@@ -187,7 +249,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 };
@@ -197,7 +259,7 @@ let FileService = class FileService extends Disposable {
                         this.logService.trace(error);
                         return null;
                     }
-                })));
+                }))));
                 fileStat.children = coalesce(resolvedEntries);
             }
             catch (error) {
@@ -209,7 +271,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 };
             }
@@ -217,7 +279,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);
@@ -245,13 +307,18 @@ let FileService = class FileService extends Disposable {
     }
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileExists', "Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 , options);
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                4,
+                "Unable to create file '{0}' that already exists when overwrite flag is not set",
+                this.resourceForError(resource)
+            ), 3 , options)));
         }
     }
     async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), options) {
         await this.doValidateCreateFile(resource, options);
         const fileStat = await this.writeFile(resource, bufferOrReadableOrStream);
-        this._onDidRunOperation.fire(( new FileOperationEvent(resource, 0 , fileStat)));
+        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 0 , fileStat))));
         return fileStat;
     }
     async writeFile(resource, bufferOrReadableOrStream, options) {
@@ -296,28 +363,54 @@ 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, 4 ))));
         }
         catch (error) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), writeFileOptions);
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                5,
+                "Unable to write file '{0}' ({1})",
+                this.resourceForError(resource),
+                ( (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(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                6,
+                "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(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnsupported1', "Unable to atomically write file '{0}' because provider does not support it.", this.resourceForError(resource)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    7,
+                    "Unable to atomically write file '{0}' because provider does not support it.",
+                    this.resourceForError(resource)
+                ))));
             }
             if (!((provider.capabilities & 2) )) {
-                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnsupported2', "Unable to atomically write file '{0}' because provider does not support unbuffered writes.", this.resourceForError(resource)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    8,
+                    "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
+                    this.resourceForError(resource)
+                ))));
             }
             if (unlock) {
-                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'writeFailedAtomicUnlock', "Unable to unlock file '{0}' because atomic write is enabled.", this.resourceForError(resource)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    9,
+                    "Unable to unlock file '{0}' because atomic write is enabled.",
+                    this.resourceForError(resource)
+                ))));
             }
         }
         let stat = undefined;
@@ -328,13 +421,22 @@ let FileService = class FileService extends Disposable {
             return undefined;
         }
         if ((stat.type & FileType.Directory) !== 0) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileIsDirectoryWriteError', "Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                10,
+                "Unable to write file '{0}' that is actually a directory",
+                this.resourceForError(resource)
+            ), 0 , options)));
         }
         this.throwIfFileIsReadonly(resource, stat);
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileModifiedError', "File Modified Since"), 3 , options);
+            throw ( (new FileOperationError(
+                localizeWithPath(_moduleId, 11, "File Modified Since"),
+                3 ,
+                options
+            )));
         }
         return stat;
     }
@@ -346,17 +448,19 @@ 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, {
@@ -373,7 +477,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 };
@@ -416,19 +520,25 @@ let FileService = class FileService extends Disposable {
     }
     restoreReadError(error, resource, options) {
         const message = ( localizeWithPath(
-            'vs/platform/files/common/fileService',
-            'err.read',
+            _moduleId,
+            12,
             "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);
@@ -476,17 +586,27 @@ let FileService = class FileService extends Disposable {
     async validateReadFile(resource, options) {
         const stat = await this.resolve(resource, { resolveMetadata: true });
         if (stat.isDirectory) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileIsDirectoryReadError', "Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                13,
+                "Unable to read file '{0}' that is actually a directory",
+                this.resourceForError(resource)
+            ), 0 , options)));
         }
         if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw new NotModifiedSinceFileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'fileNotModifiedError', "File not modified since"), stat, options);
+            throw ( (new NotModifiedSinceFileOperationError(localizeWithPath(_moduleId, 14, "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(localizeWithPath('vs/platform/files/common/fileService', 'fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), 7 , size, options);
+            throw ( (new TooLargeFileOperationError(localizeWithPath(
+                _moduleId,
+                15,
+                "Unable to read file '{0}' that is too large to open",
+                this.resourceForError(resource)
+            ), 7 , size, options)));
         }
     }
     async canMove(source, target, overwrite) {
@@ -496,7 +616,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);
@@ -513,11 +633,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 ,
             fileStat
-        )));
+        ))));
         return fileStat;
     }
     async copy(source, target, overwrite) {
@@ -525,15 +645,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 ,
             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);
@@ -585,7 +705,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);
@@ -593,7 +713,7 @@ let FileService = class FileService extends Disposable {
                 else {
                     return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
                 }
-            })));
+            }))));
         }
     }
     async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
@@ -604,21 +724,45 @@ let FileService = class FileService extends Disposable {
                 isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError1', "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system", this.resourceForError(source), this.resourceForError(target)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    16,
+                    "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(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError2', "Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    17,
+                    "Unable to move/copy when source '{0}' is parent of target '{1}'.",
+                    this.resourceForError(source),
+                    this.resourceForError(target)
+                ))));
             }
         }
         const exists = await this.exists(target);
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
-                throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError3', "Unable to move/copy '{0}' because target '{1}' already exists at destination.", this.resourceForError(source), this.resourceForError(target)), 4 );
+                throw ( (new FileOperationError(localizeWithPath(
+                    _moduleId,
+                    18,
+                    "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
+                    this.resourceForError(source),
+                    this.resourceForError(target)
+                ), 4 )));
             }
             if (sourceProvider === targetProvider) {
                 const { providerExtUri } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
-                    throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'unableToMoveCopyError4', "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
+                    throw ( (new Error(localizeWithPath(
+                        _moduleId,
+                        19,
+                        "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.",
+                        this.resourceForError(source),
+                        this.resourceForError(target)
+                    ))));
                 }
             }
         }
@@ -638,39 +782,12 @@ let FileService = class FileService extends Disposable {
         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, 0 , fileStat))));
         return fileStat;
     }
     async mkdirp(provider, directory) {
-        const directoriesToCreate = [];
         const { providerExtUri } = this.getExtUri(provider);
-        while (!providerExtUri.isEqual(directory, providerExtUri.dirname(directory))) {
-            try {
-                const stat = await provider.stat(directory);
-                if ((stat.type & FileType.Directory) === 0) {
-                    throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
-                }
-                break;
-            }
-            catch (error) {
-                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
-                    throw error;
-                }
-                directoriesToCreate.push(providerExtUri.basename(directory));
-                directory = providerExtUri.dirname(directory);
-            }
-        }
-        for (let i = directoriesToCreate.length - 1; i >= 0; i--) {
-            directory = providerExtUri.joinPath(directory, directoriesToCreate[i]);
-            try {
-                await provider.mkdir(directory);
-            }
-            catch (error) {
-                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
-                    throw error;
-                }
-            }
-        }
+        return mkdirp(providerExtUri, provider, directory);
     }
     async canDelete(resource, options) {
         try {
@@ -685,14 +802,29 @@ let FileService = class FileService extends Disposable {
         const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
         const useTrash = !!options?.useTrash;
         if (useTrash && !((provider.capabilities & 4096) )) {
-            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                20,
+                "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(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedAtomicUnsupported', "Unable to delete file '{0}' atomically because provider does not support it.", this.resourceForError(resource)));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                21,
+                "Unable to delete file '{0}' atomically because provider does not support it.",
+                this.resourceForError(resource)
+            ))));
         }
         if (useTrash && atomic) {
-            throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedTrashAndAtomicUnsupported', "Unable to atomically delete file '{0}' because using trash is enabled.", this.resourceForError(resource)));
+            throw ( (new Error(localizeWithPath(
+                _moduleId,
+                22,
+                "Unable to atomically delete file '{0}' because using trash is enabled.",
+                this.resourceForError(resource)
+            ))));
         }
         let stat = undefined;
         try {
@@ -704,13 +836,23 @@ let FileService = class FileService extends Disposable {
             this.throwIfFileIsReadonly(resource, stat);
         }
         else {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedNotFound', "Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                23,
+                "Unable to delete nonexistent file '{0}'",
+                this.resourceForError(resource)
+            ), 1 )));
         }
         const recursive = !!options?.recursive;
         if (!recursive) {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
-                throw new Error(localizeWithPath('vs/platform/files/common/fileService', 'deleteFailedNonEmptyFolder', "Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
+                throw ( (new Error(localizeWithPath(
+                    _moduleId,
+                    24,
+                    "Unable to delete non-empty folder '{0}'.",
+                    this.resourceForError(resource)
+                ))));
             }
         }
         return provider;
@@ -728,7 +870,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, 1 ))));
     }
     async cloneFile(source, target) {
         const sourceProvider = await this.withProvider(source);
@@ -753,7 +895,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()));
@@ -773,7 +915,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);
@@ -852,23 +994,25 @@ 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;
@@ -965,24 +1109,31 @@ let FileService = class FileService extends Disposable {
     }
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & 2048 ) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                25,
+                "Unable to modify read-only file '{0}'",
+                this.resourceForError(resource)
+            ), 6 )));
         }
         return provider;
     }
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
-            throw new FileOperationError(localizeWithPath('vs/platform/files/common/fileService', 'err.readonly', "Unable to modify read-only file '{0}'", this.resourceForError(resource)), 6 );
+            throw ( (new FileOperationError(localizeWithPath(
+                _moduleId,
+                25,
+                "Unable to modify read-only file '{0}'",
+                this.resourceForError(resource)
+            ), 6 )));
         }
     }
     resourceForError(resource) {
-        if (resource.scheme === Schemas.file) {
-            return resource.fsPath;
-        }
-        return ( resource.toString(true));
+        return resourceForError(resource);
     }
 };
-FileService = FileService_1 = ( __decorate([
-    ( __param(0, ILogService))
-], FileService));
+FileService = FileService_1 = ( (__decorate([
+    ( (__param(0, ILogService)))
+], FileService)));
 
-export { FileService };
+export { FileService, mkdirp };