@codingame/monaco-vscode-files-service-override 37.1.0 → 37.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "37.1.0",
+  "version": "37.3.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - files service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "37.1.0"
+    "@codingame/monaco-vscode-api": "37.3.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -10,13 +10,13 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderCapabilities, FileChangeType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { BroadcastDataChannel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/broadcast';
 
-const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(2303, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
-const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(2304, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
-const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(2305, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
-const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(2306, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
-const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(2307, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(2321, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(2322, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(2323, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(2324, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(2325, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
 const ERR_UNKNOWN_INTERNAL = message => createFileSystemProviderError(( localize(
-    2308,
+    2326,
     "Internal error occurred in IndexedDB File System Provider. ({0})",
     message
 )), FileSystemProviderErrorCode.Unknown);
@@ -157,10 +157,10 @@ class IndexedDBFileSystemProvider extends Disposable {
         if (watchCrossWindowChanges) {
             this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`)));
             this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
-                this._onDidChangeFile.fire(( changes.map(c => ({
+                this._onDidChangeFile.fire(changes.map(c => ({
                     type: c.type,
                     resource: URI.revive(c.resource)
-                }))));
+                })));
             }));
         }
     }
@@ -206,7 +206,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         if (entry.type !== FileType.Directory) {
             throw ERR_FILE_NOT_DIR;
         } else {
-            return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
+            return [...entry.children.entries()].map(([name, node]) => [name, node.type]);
         }
     }
     async readFile(resource) {
@@ -279,7 +279,11 @@ class IndexedDBFileSystemProvider extends Disposable {
         }
         if (sourceFiles.length) {
             const targetFiles = [];
-            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, "readonly", objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
+            const sourceFilesContents = await this.indexedDB.runInTransaction(
+                this.store,
+                "readonly",
+                objectStore => sourceFiles.map(([path]) => objectStore.get(path))
+            );
             for (let index = 0; index < sourceFiles.length; index++) {
                 const content = sourceFilesContents[index] instanceof Uint8Array ? sourceFilesContents[index] : isString(sourceFilesContents[index]) ? VSBuffer.fromString(sourceFilesContents[index]).buffer : undefined;
                 if (content) {
@@ -307,7 +311,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         let toDelete;
         if (opts.recursive) {
             const tree = await this.tree(resource);
-            toDelete = ( tree.map(([path]) => path));
+            toDelete = tree.map(([path]) => path);
         } else {
             if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
                 throw ERR_DIR_NOT_EMPTY;
@@ -317,12 +321,12 @@ class IndexedDBFileSystemProvider extends Disposable {
         await this.deleteKeys(toDelete);
         (await this.getFiletree()).delete(resource.path);
         toDelete.forEach(key => this.mtimes.delete(key));
-        this.triggerChanges(( toDelete.map(path => ({
+        this.triggerChanges(toDelete.map(path => ({
             resource: resource.with({
                 path
             }),
             type: FileChangeType.DELETED
-        }))));
+        })));
     }
     async tree(resource) {
         const stat = await this.stat(resource);
@@ -355,7 +359,7 @@ class IndexedDBFileSystemProvider extends Disposable {
                     type: FileType.Directory
                 }));
                 const result = await this.indexedDB.runInTransaction(this.store, "readonly", objectStore => objectStore.getAllKeys());
-                const keys = ( result.map(key => ( key.toString())));
+                const keys = result.map(key => ( key.toString()));
                 keys.forEach(key => rootNode.add(key, {
                     type: "file"
                 }));
@@ -378,18 +382,18 @@ class IndexedDBFileSystemProvider extends Disposable {
             });
             this.mtimes.set(( resource.toString()), Date.now());
         }
-        this.triggerChanges(( files.map(([resource]) => ({
+        this.triggerChanges(files.map(([resource]) => ({
             resource,
             type: FileChangeType.UPDATED
-        }))));
+        })));
     }
     async writeMany() {
         if (this.fileWriteBatch.length) {
             const fileBatch = this.fileWriteBatch.splice(0, this.fileWriteBatch.length);
             try {
-                await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => ( fileBatch.map(entry => {
+                await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => fileBatch.map(entry => {
                     return objectStore.put(entry.content, entry.resource.path);
-                })));
+                }));
             } catch (ex) {
                 if (ex instanceof DOMException && ex.name === "QuotaExceededError") {
                     throw ERR_FILE_EXCEEDS_STORAGE_QUOTA;
@@ -400,7 +404,11 @@ class IndexedDBFileSystemProvider extends Disposable {
     }
     async deleteKeys(keys) {
         if (keys.length) {
-            await this.indexedDB.runInTransaction(this.store, "readwrite", objectStore => ( keys.map(key => objectStore.delete(key))));
+            await this.indexedDB.runInTransaction(
+                this.store,
+                "readwrite",
+                objectStore => keys.map(key => objectStore.delete(key))
+            );
         }
     }
     async reset() {

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

@@ -33,7 +33,7 @@ async function mkdirp(providerExtUri, provider, directory) {
             const stat = await provider.stat(directory);
             if ((stat.type & FileType.Directory) === 0) {
                 throw ( new Error(( localize(
-                    2309,
+                    2327,
                     "Unable to create folder '{0}' that already exists but is not a directory",
                     resourceForError(directory)
                 ))));
@@ -151,15 +151,15 @@ let FileService = class FileService extends Disposable {
         return !!(provider && (provider.capabilities & capability));
     }
     listCapabilities() {
-        return ( Iterable.map(this.provider, ([scheme, provider]) => ({
+        return Iterable.map(this.provider, ([scheme, provider]) => ({
             scheme,
             capabilities: provider.capabilities
-        })));
+        }));
     }
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
             throw ( new FileOperationError(( localize(
-                2310,
+                2328,
                 "Unable to resolve filesystem provider with relative file path '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_INVALID_PATH));
@@ -169,7 +169,7 @@ let FileService = class FileService extends Disposable {
         if (!provider) {
             const error = ( new ErrorNoTelemetry());
             error.message = ( localize(
-                2311,
+                2329,
                 "ENOPRO: No file system provider found for resource '{0}'",
                 (resource.toString())
             ));
@@ -201,7 +201,7 @@ let FileService = class FileService extends Disposable {
         } catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
                 throw ( new FileOperationError(( localize(
-                    2312,
+                    2330,
                     "Unable to resolve nonexistent file '{0}'",
                     this.resourceForError(resource)
                 )), FileOperationResult.FILE_NOT_FOUND));
@@ -269,7 +269,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) : {
@@ -287,7 +287,7 @@ let FileService = class FileService extends Disposable {
                         this.logService.trace(error);
                         return null;
                     }
-                })));
+                }));
                 fileStat.children = coalesce(resolvedEntries);
             } catch (error) {
                 this.logService.trace(error);
@@ -298,7 +298,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),
@@ -313,7 +313,7 @@ let FileService = class FileService extends Disposable {
                     success: false
                 };
             }
-        })));
+        }));
     }
     async stat(resource) {
         const provider = await this.withProvider(resource);
@@ -357,7 +357,7 @@ let FileService = class FileService extends Disposable {
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
             throw ( new FileOperationError(( localize(
-                2313,
+                2331,
                 "Unable to create file '{0}' that already exists when overwrite flag is not set",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_MODIFIED_SINCE, options));
@@ -415,7 +415,7 @@ let FileService = class FileService extends Disposable {
             this._onDidRunOperation.fire(( new FileOperationEvent(resource, FileOperation.WRITE)));
         } catch (error) {
             throw ( new FileOperationError(( localize(
-                2314,
+                2332,
                 "Unable to write file '{0}' ({1})",
                 this.resourceForError(resource),
                 (ensureFileSystemProviderError(error).toString())
@@ -447,14 +447,14 @@ let FileService = class FileService extends Disposable {
         const unlock = !!options?.unlock;
         if (unlock && !(provider.capabilities & FileSystemProviderCapabilities.FileWriteUnlock)) {
             throw ( new Error(( localize(
-                2315,
+                2333,
                 "Unable to unlock file '{0}' because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (options?.append && !hasFileAppendCapability(provider)) {
             throw ( new FileOperationError(( localize(
-                2316,
+                2334,
                 "Filesystem provider for scheme '{0}' does not does not support append",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_PERMISSION_DENIED));
@@ -463,21 +463,21 @@ let FileService = class FileService extends Disposable {
         if (atomic) {
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite)) {
                 throw ( new Error(( localize(
-                    2317,
+                    2335,
                     "Unable to atomically write file '{0}' because provider does not support it.",
                     this.resourceForError(resource)
                 ))));
             }
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite)) {
                 throw ( new Error(( localize(
-                    2318,
+                    2336,
                     "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
                     this.resourceForError(resource)
                 ))));
             }
             if (unlock) {
                 throw ( new Error(( localize(
-                    2319,
+                    2337,
                     "Unable to unlock file '{0}' because atomic write is enabled.",
                     this.resourceForError(resource)
                 ))));
@@ -491,7 +491,7 @@ let FileService = class FileService extends Disposable {
         }
         if ((stat.type & FileType.Directory) !== 0) {
             throw ( new FileOperationError(( localize(
-                2320,
+                2338,
                 "Unable to write file '{0}' that is actually a directory",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_IS_DIRECTORY, options));
@@ -520,7 +520,7 @@ let FileService = class FileService extends Disposable {
                     }
                 } catch (error) {}
             }
-            throw ( new FileOperationError(( localize(2321, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options));
+            throw ( new FileOperationError(( localize(2339, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options));
         }
         return {
             stat,
@@ -604,7 +604,7 @@ let FileService = class FileService extends Disposable {
     }
     restoreReadError(error, resource, options) {
         const message = ( localize(
-            2322,
+            2340,
             "Unable to read file '{0}' ({1})",
             this.resourceForError(resource),
             (ensureFileSystemProviderError(error).toString())
@@ -666,13 +666,13 @@ let FileService = class FileService extends Disposable {
         });
         if (stat.isDirectory) {
             throw ( new FileOperationError(( localize(
-                2323,
+                2341,
                 "Unable to read file '{0}' that is actually a directory",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_IS_DIRECTORY, options));
         }
         if (typeof options?.etag === "string" && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw ( new NotModifiedSinceFileOperationError(( localize(2324, "File not modified since")), stat, options));
+            throw ( new NotModifiedSinceFileOperationError(( localize(2342, "File not modified since")), stat, options));
         }
         this.validateReadFileLimits(resource, stat.size, options);
         return stat;
@@ -680,7 +680,7 @@ let FileService = class FileService extends Disposable {
     validateReadFileLimits(resource, size, options) {
         if (typeof options?.limits?.size === "number" && size > options.limits.size) {
             throw ( new TooLargeFileOperationError(( localize(
-                2325,
+                2343,
                 "Unable to read file '{0}' that is too large to open",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_TOO_LARGE, size, options));
@@ -798,7 +798,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(
@@ -810,7 +810,7 @@ let FileService = class FileService extends Disposable {
                 } else {
                     return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
                 }
-            })));
+            }));
         }
     }
     async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
@@ -825,7 +825,7 @@ let FileService = class FileService extends Disposable {
             }
             if (isSameResourceWithDifferentPathCase && mode === "copy") {
                 throw ( new Error(( localize(
-                    2326,
+                    2344,
                     "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)
@@ -833,7 +833,7 @@ let FileService = class FileService extends Disposable {
             }
             if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
                 throw ( new Error(( localize(
-                    2327,
+                    2345,
                     "Unable to move/copy when source '{0}' is parent of target '{1}'.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -844,7 +844,7 @@ let FileService = class FileService extends Disposable {
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
                 throw ( new FileOperationError(( localize(
-                    2328,
+                    2346,
                     "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -856,7 +856,7 @@ let FileService = class FileService extends Disposable {
                 } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
                     throw ( new Error(( localize(
-                        2329,
+                        2347,
                         "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.",
                         this.resourceForError(source),
                         this.resourceForError(target)
@@ -907,7 +907,7 @@ let FileService = class FileService extends Disposable {
         const useTrash = !!options?.useTrash;
         if (useTrash && !(provider.capabilities & FileSystemProviderCapabilities.Trash)) {
             throw ( new Error(( localize(
-                2330,
+                2348,
                 "Unable to delete file '{0}' via trash because provider does not support it.",
                 this.resourceForError(resource)
             ))));
@@ -915,14 +915,14 @@ let FileService = class FileService extends Disposable {
         const atomic = options?.atomic;
         if (atomic && !(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete)) {
             throw ( new Error(( localize(
-                2331,
+                2349,
                 "Unable to delete file '{0}' atomically because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (useTrash && atomic) {
             throw ( new Error(( localize(
-                2332,
+                2350,
                 "Unable to atomically delete file '{0}' because using trash is enabled.",
                 this.resourceForError(resource)
             ))));
@@ -935,7 +935,7 @@ let FileService = class FileService extends Disposable {
             this.throwIfFileIsReadonly(resource, stat);
         } else {
             throw ( new FileOperationError(( localize(
-                2333,
+                2351,
                 "Unable to delete nonexistent file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_NOT_FOUND));
@@ -945,7 +945,7 @@ let FileService = class FileService extends Disposable {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
                 throw ( new Error(( localize(
-                    2334,
+                    2352,
                     "Unable to delete non-empty folder '{0}'.",
                     this.resourceForError(resource)
                 ))));
@@ -1278,7 +1278,7 @@ let FileService = class FileService extends Disposable {
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & FileSystemProviderCapabilities.Readonly) {
             throw ( new FileOperationError(( localize(
-                2335,
+                2353,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_PERMISSION_DENIED));
@@ -1288,7 +1288,7 @@ let FileService = class FileService extends Disposable {
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
             throw ( new FileOperationError(( localize(
-                2335,
+                2353,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             )), FileOperationResult.FILE_PERMISSION_DENIED));

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

@@ -80,7 +80,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === "number" && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(( localize(2342, "File is too large to open")), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(( localize(2360, "File is too large to open")), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -56,10 +56,10 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         AbstractTextFileService_1 = this;
     }
     static {
-        this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("textFileCreate.source", ( localize(20051, "File Created")));
+        this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource("textFileCreate.source", ( localize(22194, "File Created")));
     }
     static {
-        this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("textFileOverwrite.source", ( localize(20052, "File Replaced")));
+        this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource("textFileOverwrite.source", ( localize(22195, "File Replaced")));
     }
     constructor(
         fileService,
@@ -108,7 +108,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localize(20053, "Text File Model Decorations"));
+                this.label = ( localize(22196, "Text File Model Decorations"));
                 this._onDidChange = this._register(( new Emitter()));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -143,20 +143,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(20054, "Deleted, Read-only"))
+                        tooltip: ( localize(22197, "Deleted, Read-only"))
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(20055, "Read-only"))
+                        tooltip: ( localize(22198, "Read-only"))
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(20056, "Deleted"))
+                        tooltip: ( localize(22199, "Deleted"))
                     };
                 }
                 return undefined;
@@ -207,7 +207,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } catch (error) {
             cts.dispose(true);
             if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
-                throw ( new TextFileOperationError(( localize(20057, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
+                throw ( new TextFileOperationError(( localize(22200, "File seems to be binary and cannot be opened as text")), TextFileOperationResult.FILE_IS_BINARY, options));
             }
             else {
                 throw error;
@@ -215,14 +215,14 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
     }
     async create(operations, undoInfo) {
-        const operationsWithContents = await Promise.all(( operations.map(async operation => {
+        const operationsWithContents = await Promise.all(operations.map(async operation => {
             const contents = await this.getEncodedReadable(operation.resource, operation.value);
             return {
                 resource: operation.resource,
                 contents,
                 overwrite: operation.options?.overwrite
             };
-        })));
+        }));
         return this.workingCopyFileService.create(operationsWithContents, CancellationToken.None, undoInfo);
     }
     async write(resource, value, options) {
@@ -481,17 +481,17 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                20058,
+                22201,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                20059,
+                22202,
                 "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
                 basename(resource),
                 basename(dirname(resource))
             )),
-            primaryButton: ( localize(20060, "&&Replace"))
+            primaryButton: ( localize(22203, "&&Replace"))
         });
         return confirmed;
     }
@@ -501,12 +501,12 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         } = await this.dialogService.confirm({
             type: "warning",
             message: ( localize(
-                20061,
+                22204,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(20062, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(20063, "&&Save Anyway"))
+            detail: ( localize(22205, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(22206, "&&Save Anyway"))
         });
         return confirmed;
     }

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -70,7 +70,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
             return {
                 onSaveError(error, model) {
                     notificationService.error(( localize(
-                        20067,
+                        22210,
                         "Failed to save '{0}': {1}",
                         model.name,
                         toErrorMessage(error, false)
@@ -217,7 +217,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                 const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
                 if (modelsToRestore) {
                     this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                    await Promises.settled(( modelsToRestore.map(async modelToRestore => {
+                    await Promises.settled(modelsToRestore.map(async modelToRestore => {
                         const target = this.uriIdentityService.asCanonicalUri(modelToRestore.target);
                         const restoredModel = await this.resolve(target, {
                             reload: {
@@ -234,7 +234,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                                 restoredModel.updateTextEditorModel(undefined, modelToRestore.language.id);
                             }
                         }
-                    })));
+                    }));
                 }
             })());
             break;

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -26,13 +26,13 @@ let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
         const cts = ( new CancellationTokenSource(token));
         model.textEditorModel?.pushStackElement();
         progress.report({
-            message: ( localize(20068, "Running Code Actions and Formatters..."))
+            message: ( localize(22211, "Running Code Actions and Formatters..."))
         });
         let bubbleCancel = false;
         await this.progressService.withProgress({
             priority: NotificationPriority.URGENT,
             location: ProgressLocation.Notification,
-            cancellable: ( localize(20069, "Skip")),
+            cancellable: ( localize(22212, "Skip")),
             delay: model.isDirty() ? 5000 : 3000
         }, async progress => {
             const participants = Array.from(this.saveParticipants).sort((a, b) => {