@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/files/browser/fileImportExport.js

@@ -41,9 +41,19 @@ import Severity$1 from '../../../../base/common/severity.js';
 
 var BrowserFileUpload_1, FileDownload_1;
 let BrowserFileUpload = class BrowserFileUpload {
-    static { BrowserFileUpload_1 = this; }
-    static { this.MAX_PARALLEL_UPLOADS = 20; }
-    constructor(progressService, dialogService, explorerService, editorService, fileService) {
+    static {
+        BrowserFileUpload_1 = this;
+    }
+    static {
+        this.MAX_PARALLEL_UPLOADS = 20;
+    }
+    constructor(
+        progressService,
+        dialogService,
+        explorerService,
+        editorService,
+        fileService
+    ) {
         this.progressService = progressService;
         this.dialogService = dialogService;
         this.explorerService = explorerService;
@@ -56,16 +66,21 @@ let BrowserFileUpload = class BrowserFileUpload {
             location: ProgressLocation.Window,
             delay: 800,
             cancellable: true,
-            title: ( localize(8077, "Uploading"))
-        }, async (progress) => this.doUpload(target, this.toTransfer(source), progress, cts.token), () => cts.dispose(true));
-        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => uploadPromise);
+            title: ( localize(8389, "Uploading"))
+        }, async progress => this.doUpload(target, this.toTransfer(source), progress, cts.token), () => cts.dispose(true));
+        this.progressService.withProgress({
+            location: VIEW_ID,
+            delay: 500
+        }, () => uploadPromise);
         return uploadPromise;
     }
     toTransfer(source) {
         if (isDragEvent(source)) {
             return source.dataTransfer;
         }
-        const transfer = { items: [] };
+        const transfer = {
+            items: []
+        };
         for (const file of source) {
             transfer.items.push({
                 webkitGetAsEntry: () => {
@@ -73,7 +88,9 @@ let BrowserFileUpload = class BrowserFileUpload {
                         name: file.name,
                         isDirectory: false,
                         isFile: true,
-                        createReader: () => { throw ( new Error('Unsupported for files')); },
+                        createReader: () => {
+                            throw ( new Error("Unsupported for files"));
+                        },
                         file: resolve => resolve(file)
                     };
                 }
@@ -90,7 +107,9 @@ let BrowserFileUpload = class BrowserFileUpload {
         const results = [];
         const operation = {
             startTime: Date.now(),
-            progressScheduler: ( new RunOnceWorker(steps => { progress.report(steps[steps.length - 1]); }, 1000)),
+            progressScheduler: ( new RunOnceWorker(steps => {
+                progress.report(steps[steps.length - 1]);
+            }, 1000)),
             filesTotal: entries.length,
             filesUploaded: 0,
             totalBytesUploaded: 0
@@ -102,17 +121,18 @@ let BrowserFileUpload = class BrowserFileUpload {
                     return;
                 }
                 if (target && entry.name && target.getChild(entry.name)) {
-                    const { confirmed } = await this.dialogService.confirm(getFileOverwriteConfirm(entry.name));
+                    const {
+                        confirmed
+                    } = await this.dialogService.confirm(getFileOverwriteConfirm(entry.name));
                     if (!confirmed) {
                         return;
                     }
-                    await this.explorerService.applyBulkEdit([( new ResourceFileEdit(
-                        joinPath(target.resource, entry.name),
-                        undefined,
-                        { recursive: true, folder: target.getChild(entry.name)?.isDirectory }
-                    ))], {
-                        undoLabel: ( localize(8078, "Overwrite {0}", entry.name)),
-                        progressLabel: ( localize(8079, "Overwriting {0}", entry.name)),
+                    await this.explorerService.applyBulkEdit([( new ResourceFileEdit(joinPath(target.resource, entry.name), undefined, {
+                        recursive: true,
+                        folder: target.getChild(entry.name)?.isDirectory
+                    }))], {
+                        undoLabel: ( localize(8390, "Overwrite {0}", entry.name)),
+                        progressLabel: ( localize(8391, "Overwriting {0}", entry.name))
                     });
                     if (token.isCancellationRequested) {
                         return;
@@ -127,7 +147,12 @@ let BrowserFileUpload = class BrowserFileUpload {
         operation.progressScheduler.dispose();
         const firstUploadedFile = results[0];
         if (!token.isCancellationRequested && firstUploadedFile?.isFile) {
-            await this.editorService.openEditor({ resource: firstUploadedFile.resource, options: { pinned: true } });
+            await this.editorService.openEditor({
+                resource: firstUploadedFile.resource,
+                options: {
+                    pinned: true
+                }
+            });
         }
     }
     async doUploadEntry(entry, parentResource, target, progress, operation, token) {
@@ -143,10 +168,9 @@ let BrowserFileUpload = class BrowserFileUpload {
             if (fileSize < ByteSize.MB) {
                 if (operation.filesTotal === 1) {
                     message = `${entry.name}`;
-                }
-                else {
+                } else {
                     message = ( localize(
-                        8080,
+                        8392,
                         "{0} of {1} files ({2}/s)",
                         operation.filesUploaded,
                         operation.filesTotal,
@@ -156,7 +180,7 @@ let BrowserFileUpload = class BrowserFileUpload {
             }
             else {
                 message = ( localize(
-                    8081,
+                    8393,
                     "{0} ({1} of {2}, {3}/s)",
                     entry.name,
                     ByteSize.formatSize(fileBytesUploaded),
@@ -164,7 +188,9 @@ let BrowserFileUpload = class BrowserFileUpload {
                     ByteSize.formatSize(bytesUploadedPerSecond)
                 ));
             }
-            operation.progressScheduler.work({ message });
+            operation.progressScheduler.work({
+                message
+            });
         };
         operation.filesUploaded++;
         reportProgress(0, 0);
@@ -174,13 +200,16 @@ let BrowserFileUpload = class BrowserFileUpload {
             if (token.isCancellationRequested) {
                 return undefined;
             }
-            if (typeof file.stream === 'function' && file.size > ByteSize.MB) {
+            if (typeof file.stream === "function" && file.size > ByteSize.MB) {
                 await this.doUploadFileBuffered(resource, file, reportProgress, token);
             }
             else {
                 await this.doUploadFileUnbuffered(resource, file, reportProgress);
             }
-            return { isFile: true, resource };
+            return {
+                isFile: true,
+                resource
+            };
         }
         else {
             await this.fileService.createFolder(resource);
@@ -194,8 +223,7 @@ let BrowserFileUpload = class BrowserFileUpload {
                 const childEntriesChunk = await ( new Promise((resolve, reject) => dirReader.readEntries(resolve, reject)));
                 if (childEntriesChunk.length > 0) {
                     childEntries.push(...childEntriesChunk);
-                }
-                else {
+                } else {
                     done = true;
                 }
             } while (!done && !token.isCancellationRequested);
@@ -206,19 +234,23 @@ let BrowserFileUpload = class BrowserFileUpload {
             for (const childEntry of childEntries) {
                 if (childEntry.isFile) {
                     fileChildEntries.push(childEntry);
-                }
-                else if (childEntry.isDirectory) {
+                } else if (childEntry.isDirectory) {
                     folderChildEntries.push(childEntry);
                 }
             }
             const fileUploadQueue = ( new Limiter(BrowserFileUpload_1.MAX_PARALLEL_UPLOADS));
             await Promises.settled(( fileChildEntries.map(fileChildEntry => {
-                return fileUploadQueue.queue(() => this.doUploadEntry(fileChildEntry, resource, folderTarget, progress, operation, token));
+                return fileUploadQueue.queue(
+                    () => this.doUploadEntry(fileChildEntry, resource, folderTarget, progress, operation, token)
+                );
             })));
             for (const folderChildEntry of folderChildEntries) {
                 await this.doUploadEntry(folderChildEntry, resource, folderTarget, progress, operation, token);
             }
-            return { isFile: false, resource };
+            return {
+                isFile: false,
+                resource
+            };
         }
     }
     async doUploadFileBuffered(resource, file, progressReporter, token) {
@@ -242,8 +274,7 @@ let BrowserFileUpload = class BrowserFileUpload {
                 res = await reader.read();
             }
             writeableStream.end(undefined);
-        }
-        catch (error) {
+        } catch (error) {
             writeableStream.error(error);
             writeableStream.end();
         }
@@ -255,19 +286,17 @@ let BrowserFileUpload = class BrowserFileUpload {
     doUploadFileUnbuffered(resource, file, progressReporter) {
         return ( new Promise((resolve, reject) => {
             const reader = ( new FileReader());
-            reader.onload = async (event) => {
+            reader.onload = async event => {
                 try {
                     if (event.target?.result instanceof ArrayBuffer) {
                         const buffer = VSBuffer.wrap(( new Uint8Array(event.target.result)));
                         await this.fileService.writeFile(resource, buffer);
                         progressReporter(file.size, buffer.byteLength);
-                    }
-                    else {
-                        throw ( new Error('Could not read from dropped file.'));
+                    } else {
+                        throw ( new Error("Could not read from dropped file."));
                     }
                     resolve();
-                }
-                catch (error) {
+                } catch (error) {
                     reject(error);
                 }
             };
@@ -275,15 +304,21 @@ let BrowserFileUpload = class BrowserFileUpload {
         }));
     }
 };
-BrowserFileUpload = BrowserFileUpload_1 = ( __decorate([
-    ( __param(0, IProgressService)),
-    ( __param(1, IDialogService)),
-    ( __param(2, IExplorerService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IFileService))
-], BrowserFileUpload));
+BrowserFileUpload = BrowserFileUpload_1 = ( __decorate([( __param(0, IProgressService)), ( __param(1, IDialogService)), ( __param(2, IExplorerService)), ( __param(3, IEditorService)), ( __param(4, IFileService))], BrowserFileUpload));
 let ExternalFileImport = class ExternalFileImport {
-    constructor(fileService, hostService, contextService, configurationService, dialogService, workspaceEditingService, explorerService, editorService, progressService, notificationService, instantiationService) {
+    constructor(
+        fileService,
+        hostService,
+        contextService,
+        configurationService,
+        dialogService,
+        workspaceEditingService,
+        explorerService,
+        editorService,
+        progressService,
+        notificationService,
+        instantiationService
+    ) {
         this.fileService = fileService;
         this.hostService = hostService;
         this.contextService = contextService;
@@ -302,61 +337,59 @@ let ExternalFileImport = class ExternalFileImport {
             location: ProgressLocation.Window,
             delay: 800,
             cancellable: true,
-            title: ( localize(8082, "Copying..."))
+            title: ( localize(8394, "Copying..."))
         }, async () => await this.doImport(target, source, targetWindow, cts.token), () => cts.dispose(true));
-        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => importPromise);
+        this.progressService.withProgress({
+            location: VIEW_ID,
+            delay: 500
+        }, () => importPromise);
         return importPromise;
     }
     async doImport(target, source, targetWindow, token) {
         const candidateFiles = coalesce(( (await this.instantiationService.invokeFunction(accessor => extractEditorsAndFilesDropData(accessor, source))).map(editor => editor.resource)));
         await Promise.all(( candidateFiles.map(resource => this.fileService.activateProvider(resource.scheme))));
         const files = coalesce(candidateFiles.filter(resource => this.fileService.hasProvider(resource)));
-        const resolvedFiles = await this.fileService.resolveAll(( files.map(file => ({ resource: file }))));
+        const resolvedFiles = await this.fileService.resolveAll(( files.map(file => ({
+            resource: file
+        }))));
         if (token.isCancellationRequested) {
             return;
         }
         this.hostService.focus(targetWindow);
-        const folders = ( resolvedFiles.filter(resolvedFile => resolvedFile.success && resolvedFile.stat?.isDirectory).map(resolvedFile => ({ uri: resolvedFile.stat.resource })));
+        const folders = ( resolvedFiles.filter(resolvedFile => resolvedFile.success && resolvedFile.stat?.isDirectory).map(resolvedFile => ({
+            uri: resolvedFile.stat.resource
+        })));
         if (folders.length > 0 && target.isRoot) {
             let ImportChoice;
-            (function (ImportChoice) {
+            (function(ImportChoice) {
                 ImportChoice[ImportChoice["Copy"] = 1] = "Copy";
                 ImportChoice[ImportChoice["Add"] = 2] = "Add";
             })(ImportChoice || (ImportChoice = {}));
-            const buttons = [
-                {
-                    label: folders.length > 1 ?
-                        ( localize(8083, "&&Copy Folders")) :
-                        ( localize(8084, "&&Copy Folder")),
-                    run: () => ImportChoice.Copy
-                }
-            ];
+            const buttons = [{
+                label: folders.length > 1 ? ( localize(8395, "&&Copy Folders")) : ( localize(8396, "&&Copy Folder")),
+                run: () => ImportChoice.Copy
+            }];
             let message;
             const workspaceFolderSchemas = ( this.contextService.getWorkspace().folders.map(folder => folder.uri.scheme));
             if (( folders.some(folder => workspaceFolderSchemas.indexOf(folder.uri.scheme) >= 0))) {
                 buttons.unshift({
-                    label: folders.length > 1 ?
-                        ( localize(8085, "&&Add Folders to Workspace")) :
-                        ( localize(8086, "&&Add Folder to Workspace")),
+                    label: folders.length > 1 ? ( localize(8397, "&&Add Folders to Workspace")) : ( localize(8398, "&&Add Folder to Workspace")),
                     run: () => ImportChoice.Add
                 });
-                message = folders.length > 1 ?
-                    ( localize(
-                    8087,
+                message = folders.length > 1 ? ( localize(
+                    8399,
                     "Do you want to copy the folders or add the folders to the workspace?"
-                )) :
-                    ( localize(
-                    8088,
+                )) : ( localize(
+                    8400,
                     "Do you want to copy '{0}' or add '{0}' as a folder to the workspace?",
                     basename(folders[0].uri)
                 ));
+            } else {
+                message = folders.length > 1 ? ( localize(8401, "Are you sure to want to copy folders?")) : ( localize(8402, "Are you sure to want to copy '{0}'?", basename(folders[0].uri)));
             }
-            else {
-                message = folders.length > 1 ?
-                    ( localize(8089, "Are you sure to want to copy folders?")) :
-                    ( localize(8090, "Are you sure to want to copy '{0}'?", basename(folders[0].uri)));
-            }
-            const { result } = await this.dialogService.prompt({
+            const {
+                result
+            } = await this.dialogService.prompt({
                 type: Severity$1.Info,
                 message,
                 buttons,
@@ -387,7 +420,7 @@ let ExternalFileImport = class ExternalFileImport {
                 });
             }
             let inaccessibleFileCount = 0;
-            const resourcesFiltered = coalesce((await Promises.settled(( resources.map(async (resource) => {
+            const resourcesFiltered = coalesce((await Promises.settled(( resources.map(async resource => {
                 const fileDoesNotExist = !(await this.fileService.exists(resource));
                 if (fileDoesNotExist) {
                     inaccessibleFileCount++;
@@ -402,51 +435,54 @@ let ExternalFileImport = class ExternalFileImport {
                 return resource;
             })))));
             if (inaccessibleFileCount > 0) {
-                this.notificationService.error(inaccessibleFileCount > 1 ? ( localize(8091, "Some or all of the dropped files could not be accessed for import.")) : ( localize(8092, "The dropped file could not be accessed for import.")));
+                this.notificationService.error(inaccessibleFileCount > 1 ? ( localize(8403, "Some or all of the dropped files could not be accessed for import.")) : ( localize(8404, "The dropped file could not be accessed for import.")));
             }
             const resourceFileEdits = ( resourcesFiltered.map(resource => {
                 const sourceFileName = basename(resource);
                 const targetFile = joinPath(target.resource, sourceFileName);
-                return ( new ResourceFileEdit(resource, targetFile, { overwrite: true, copy: true }));
+                return ( new ResourceFileEdit(resource, targetFile, {
+                    overwrite: true,
+                    copy: true
+                }));
             }));
             const undoLevel = this.configurationService.getValue().explorer.confirmUndo;
             await this.explorerService.applyBulkEdit(resourceFileEdits, {
-                undoLabel: resourcesFiltered.length === 1 ?
-                    ( localize(8093, "Import {0}", basename(resourcesFiltered[0]))) :
-                    ( localize(8094, "Import {0} resources", resourcesFiltered.length)),
-                progressLabel: resourcesFiltered.length === 1 ?
-                    ( localize(8095, "Copying {0}", basename(resourcesFiltered[0]))) :
-                    ( localize(8096, "Copying {0} resources", resourcesFiltered.length)),
+                undoLabel: resourcesFiltered.length === 1 ? ( localize(8405, "Import {0}", basename(resourcesFiltered[0]))) : ( localize(8406, "Import {0} resources", resourcesFiltered.length)),
+                progressLabel: resourcesFiltered.length === 1 ? ( localize(8407, "Copying {0}", basename(resourcesFiltered[0]))) : ( localize(8408, "Copying {0} resources", resourcesFiltered.length)),
                 progressLocation: ProgressLocation.Window,
-                confirmBeforeUndo: undoLevel === UndoConfirmLevel.Verbose || undoLevel === UndoConfirmLevel.Default,
+                confirmBeforeUndo: undoLevel === UndoConfirmLevel.Verbose || undoLevel === UndoConfirmLevel.Default
             });
             const autoOpen = this.configurationService.getValue().explorer.autoOpenDroppedFile;
             if (autoOpen && resourceFileEdits.length === 1) {
                 const item = this.explorerService.findClosest(resourceFileEdits[0].newResource);
                 if (item && !item.isDirectory) {
-                    this.editorService.openEditor({ resource: item.resource, options: { pinned: true } });
+                    this.editorService.openEditor({
+                        resource: item.resource,
+                        options: {
+                            pinned: true
+                        }
+                    });
                 }
             }
         }
     }
 };
-ExternalFileImport = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IHostService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, IWorkspaceEditingService)),
-    ( __param(6, IExplorerService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IProgressService)),
-    ( __param(9, INotificationService)),
-    ( __param(10, IInstantiationService))
-], ExternalFileImport));
+ExternalFileImport = ( __decorate([( __param(0, IFileService)), ( __param(1, IHostService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IConfigurationService)), ( __param(4, IDialogService)), ( __param(5, IWorkspaceEditingService)), ( __param(6, IExplorerService)), ( __param(7, IEditorService)), ( __param(8, IProgressService)), ( __param(9, INotificationService)), ( __param(10, IInstantiationService))], ExternalFileImport));
 let FileDownload = class FileDownload {
-    static { FileDownload_1 = this; }
-    static { this.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY = 'workbench.explorer.downloadPath'; }
-    constructor(fileService, explorerService, progressService, logService, fileDialogService, storageService) {
+    static {
+        FileDownload_1 = this;
+    }
+    static {
+        this.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY = "workbench.explorer.downloadPath";
+    }
+    constructor(
+        fileService,
+        explorerService,
+        progressService,
+        logService,
+        fileDialogService,
+        storageService
+    ) {
         this.fileService = fileService;
         this.explorerService = explorerService;
         this.progressService = progressService;
@@ -460,9 +496,12 @@ let FileDownload = class FileDownload {
             location: ProgressLocation.Window,
             delay: 800,
             cancellable: isWeb,
-            title: ( localize(8097, "Downloading"))
-        }, async (progress) => this.doDownload(source, progress, cts), () => cts.dispose(true));
-        this.progressService.withProgress({ location: VIEW_ID, delay: 500 }, () => downloadPromise);
+            title: ( localize(8409, "Downloading"))
+        }, async progress => this.doDownload(source, progress, cts), () => cts.dispose(true));
+        this.progressService.withProgress({
+            location: VIEW_ID,
+            delay: 500
+        }, () => downloadPromise);
         return downloadPromise;
     }
     async doDownload(sources, progress, cts) {
@@ -479,7 +518,9 @@ let FileDownload = class FileDownload {
         }
     }
     async doDownloadBrowser(resource, progress, cts) {
-        const stat = await this.fileService.resolve(resource, { resolveMetadata: true });
+        const stat = await this.fileService.resolve(resource, {
+            resolveMetadata: true
+        });
         if (cts.token.isCancellationRequested) {
             return;
         }
@@ -491,22 +532,24 @@ let FileDownload = class FileDownload {
                 const parentFolder = await activeWindow.showDirectoryPicker();
                 const operation = {
                     startTime: Date.now(),
-                    progressScheduler: ( new RunOnceWorker(steps => { progress.report(steps[steps.length - 1]); }, 1000)),
+                    progressScheduler: ( new RunOnceWorker(steps => {
+                        progress.report(steps[steps.length - 1]);
+                    }, 1000)),
                     filesTotal: stat.isDirectory ? 0 : 1,
                     filesDownloaded: 0,
                     totalBytesDownloaded: 0,
                     fileBytesDownloaded: 0
                 };
                 if (stat.isDirectory) {
-                    const targetFolder = await parentFolder.getDirectoryHandle(stat.name, { create: true });
+                    const targetFolder = await parentFolder.getDirectoryHandle(stat.name, {
+                        create: true
+                    });
                     await this.downloadFolderBrowser(stat, targetFolder, operation, cts.token);
-                }
-                else {
+                } else {
                     await this.downloadFileBrowser(parentFolder, stat, operation, cts.token);
                 }
                 operation.progressScheduler.dispose();
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.warn(error);
                 cts.cancel();
             }
@@ -514,9 +557,12 @@ let FileDownload = class FileDownload {
         else if (stat.isFile) {
             let bufferOrUri;
             try {
-                bufferOrUri = (await this.fileService.readFile(stat.resource, { limits: { size: maxBlobDownloadSize } }, cts.token)).value.buffer;
-            }
-            catch (error) {
+                bufferOrUri = (await this.fileService.readFile(stat.resource, {
+                    limits: {
+                        size: maxBlobDownloadSize
+                    }
+                }, cts.token)).value.buffer;
+            } catch (error) {
                 bufferOrUri = FileAccess.uriToBrowserUri(stat.resource);
             }
             if (!cts.token.isCancellationRequested) {
@@ -566,7 +612,9 @@ let FileDownload = class FileDownload {
         operation.filesDownloaded++;
         operation.fileBytesDownloaded = 0;
         this.reportProgress(file.name, 0, 0, operation);
-        const targetFile = await targetFolder.getFileHandle(file.name, { create: true });
+        const targetFile = await targetFolder.getFileHandle(file.name, {
+            create: true
+        });
         const targetFileWriter = await targetFile.createWritable();
         if (file.size > ByteSize.MB) {
             return this.downloadFileBufferedBrowser(file.resource, targetFileWriter, operation, token);
@@ -575,17 +623,20 @@ let FileDownload = class FileDownload {
     }
     async downloadFolderBrowser(folder, targetFolder, operation, token) {
         if (folder.children) {
-            operation.filesTotal += (( folder.children.map(child => child.isFile))).length;
+            operation.filesTotal += ( folder.children.map(child => child.isFile)).length;
             for (const child of folder.children) {
                 if (token.isCancellationRequested) {
                     return;
                 }
                 if (child.isFile) {
                     await this.downloadFileBrowser(targetFolder, child, operation, token);
-                }
-                else {
-                    const childFolder = await targetFolder.getDirectoryHandle(child.name, { create: true });
-                    const resolvedChildFolder = await this.fileService.resolve(child.resource, { resolveMetadata: true });
+                } else {
+                    const childFolder = await targetFolder.getDirectoryHandle(child.name, {
+                        create: true
+                    });
+                    const resolvedChildFolder = await this.fileService.resolve(child.resource, {
+                        resolveMetadata: true
+                    });
                     await this.downloadFolderBrowser(resolvedChildFolder, childFolder, operation, token);
                 }
             }
@@ -599,10 +650,9 @@ let FileDownload = class FileDownload {
         if (fileSize < ByteSize.MB) {
             if (operation.filesTotal === 1) {
                 message = name;
-            }
-            else {
+            } else {
                 message = ( localize(
-                    8098,
+                    8410,
                     "{0} of {1} files ({2}/s)",
                     operation.filesDownloaded,
                     operation.filesTotal,
@@ -612,7 +662,7 @@ let FileDownload = class FileDownload {
         }
         else {
             message = ( localize(
-                8099,
+                8411,
                 "{0} ({1} of {2}, {3}/s)",
                 name,
                 ByteSize.formatSize(operation.fileBytesDownloaded),
@@ -620,70 +670,77 @@ let FileDownload = class FileDownload {
                 ByteSize.formatSize(bytesDownloadedPerSecond)
             ));
         }
-        operation.progressScheduler.work({ message });
+        operation.progressScheduler.work({
+            message
+        });
     }
     async doDownloadNative(explorerItem, progress, cts) {
-        progress.report({ message: explorerItem.name });
+        progress.report({
+            message: explorerItem.name
+        });
         let defaultUri;
-        const lastUsedDownloadPath = this.storageService.get(FileDownload_1.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY, StorageScope.APPLICATION);
+        const lastUsedDownloadPath = this.storageService.get(
+            FileDownload_1.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY,
+            StorageScope.APPLICATION
+        );
         if (lastUsedDownloadPath) {
             defaultUri = joinPath(URI.file(lastUsedDownloadPath), explorerItem.name);
-        }
-        else {
-            defaultUri = joinPath(explorerItem.isDirectory ?
-                await this.fileDialogService.defaultFolderPath(Schemas.file) :
-                await this.fileDialogService.defaultFilePath(Schemas.file), explorerItem.name);
+        } else {
+            defaultUri = joinPath(
+                explorerItem.isDirectory ? await this.fileDialogService.defaultFolderPath(Schemas.file) : await this.fileDialogService.defaultFilePath(Schemas.file),
+                explorerItem.name
+            );
         }
         const destination = await this.fileDialogService.showSaveDialog({
             availableFileSystems: [Schemas.file],
-            saveLabel: ( localize(8100, "Download")),
-            title: ( localize(8101, "Choose Where to Download")),
+            saveLabel: ( localize(8412, "Download")),
+            title: ( localize(8413, "Choose Where to Download")),
             defaultUri
         });
         if (destination) {
-            this.storageService.store(FileDownload_1.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY, dirname(destination).fsPath, StorageScope.APPLICATION, StorageTarget.MACHINE);
-            await this.explorerService.applyBulkEdit([( new ResourceFileEdit(explorerItem.resource, destination, { overwrite: true, copy: true }))], {
-                undoLabel: ( localize(8102, "Download {0}", explorerItem.name)),
-                progressLabel: ( localize(8103, "Downloading {0}", explorerItem.name)),
+            this.storageService.store(
+                FileDownload_1.LAST_USED_DOWNLOAD_PATH_STORAGE_KEY,
+                dirname(destination).fsPath,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+            await this.explorerService.applyBulkEdit([( new ResourceFileEdit(explorerItem.resource, destination, {
+                overwrite: true,
+                copy: true
+            }))], {
+                undoLabel: ( localize(8414, "Download {0}", explorerItem.name)),
+                progressLabel: ( localize(8415, "Downloading {0}", explorerItem.name)),
                 progressLocation: ProgressLocation.Window
             });
-        }
-        else {
+        } else {
             cts.cancel();
         }
     }
 };
-FileDownload = FileDownload_1 = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IExplorerService)),
-    ( __param(2, IProgressService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IFileDialogService)),
-    ( __param(5, IStorageService))
-], FileDownload));
+FileDownload = FileDownload_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IExplorerService)), ( __param(2, IProgressService)), ( __param(3, ILogService)), ( __param(4, IFileDialogService)), ( __param(5, IStorageService))], FileDownload));
 function getFileOverwriteConfirm(name) {
     return {
         message: ( localize(
-            8104,
+            8416,
             "A file or folder with the name '{0}' already exists in the destination folder. Do you want to replace it?",
             name
         )),
-        detail: ( localize(8105, "This action is irreversible!")),
-        primaryButton: ( localize(8106, "&&Replace")),
-        type: 'warning'
+        detail: ( localize(8417, "This action is irreversible!")),
+        primaryButton: ( localize(8418, "&&Replace")),
+        type: "warning"
     };
 }
 function getMultipleFilesOverwriteConfirm(files) {
     if (files.length > 1) {
         return {
             message: ( localize(
-                8107,
+                8419,
                 "The following {0} files and/or folders already exist in the destination folder. Do you want to replace them?",
                 files.length
             )),
-            detail: getFileNamesMessage(files) + '\n' + ( localize(8105, "This action is irreversible!")),
-            primaryButton: ( localize(8106, "&&Replace")),
-            type: 'warning'
+            detail: getFileNamesMessage(files) + "\n" + ( localize(8417, "This action is irreversible!")),
+            primaryButton: ( localize(8418, "&&Replace")),
+            type: "warning"
         };
     }
     return getFileOverwriteConfirm(basename(files[0]));