@codingame/monaco-vscode-files-service-override 7.1.0 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "7.1.0",
+  "version": "8.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@7.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@8.0.0"
   }
 }

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

@@ -5,20 +5,18 @@ import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ExtUri } from 'vscode/vscode/vs/base/common/resources';
 import { isString } from 'vscode/vscode/vs/base/common/types';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderCapabilities, FileChangeType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
 import { DBClosedError } from 'vscode/vscode/vs/base/browser/indexedDB';
 import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
 
-const _moduleId = "vs/platform/files/browser/indexedDBFileSystemProvider";
-const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localizeWithPath(_moduleId, 0, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
-const ERR_FILE_IS_DIR = createFileSystemProviderError(( localizeWithPath(_moduleId, 1, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
-const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localizeWithPath(_moduleId, 2, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
-const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localizeWithPath(_moduleId, 3, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
-const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localizeWithPath(_moduleId, 4, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
-const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localizeWithPath(
-    _moduleId,
-    5,
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(718, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(719, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(720, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(721, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(722, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localize(
+    723,
     "Internal error occurred in IndexedDB File System Provider. ({0})",
     message
 )), FileSystemProviderErrorCode.Unknown);

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

@@ -12,14 +12,13 @@ import { Schemas } from 'vscode/vscode/vs/base/common/network';
 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 { localize } from 'vscode/vscode/vs/nls';
 import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, FileOperationResult, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, FilePermission, FileSystemProviderCapabilities, etag, FileOperationEvent, FileOperation, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'vscode/vscode/vs/platform/files/common/files';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
 
 var FileService_1;
-const _moduleId = "vs/platform/files/common/fileService";
 function resourceForError(resource) {
     if (resource.scheme === Schemas.file) {
         return resource.fsPath;
@@ -34,9 +33,8 @@ async function mkdirp(providerExtUri, provider, directory) {
         try {
             const stat = await provider.stat(directory);
             if ((stat.type & FileType.Directory) === 0) {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    0,
+                throw ( (new Error(localize(
+                    690,
                     "Unable to create folder '{0}' that already exists but is not a directory",
                     resourceForError(directory)
                 ))));
@@ -150,9 +148,8 @@ let FileService = class FileService extends Disposable {
     }
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                1,
+            throw ( (new FileOperationError(localize(
+                691,
                 "Unable to resolve filesystem provider with relative file path '{0}'",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_INVALID_PATH)));
@@ -161,9 +158,8 @@ let FileService = class FileService extends Disposable {
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
             const error = ( (new ErrorNoTelemetry()));
-            error.message = ( localizeWithPath(
-                _moduleId,
-                2,
+            error.message = ( localize(
+                692,
                 "ENOPRO: No file system provider found for resource '{0}'",
                  (resource.toString())
             ));
@@ -195,9 +191,8 @@ let FileService = class FileService extends Disposable {
         }
         catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
-                throw ( (new FileOperationError(localizeWithPath(
-                    _moduleId,
-                    3,
+                throw ( (new FileOperationError(localize(
+                    693,
                     "Unable to resolve nonexistent file '{0}'",
                     this.resourceForError(resource)
                 ), FileOperationResult.FILE_NOT_FOUND)));
@@ -307,9 +302,8 @@ let FileService = class FileService extends Disposable {
     }
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                4,
+            throw ( (new FileOperationError(localize(
+                694,
                 "Unable to create file '{0}' that already exists when overwrite flag is not set",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_MODIFIED_SINCE, options)));
@@ -366,9 +360,8 @@ let FileService = class FileService extends Disposable {
             this._onDidRunOperation.fire(( (new FileOperationEvent(resource, FileOperation.WRITE))));
         }
         catch (error) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                5,
+            throw ( (new FileOperationError(localize(
+                695,
                 "Unable to write file '{0}' ({1})",
                 this.resourceForError(resource),
                 ( (ensureFileSystemProviderError(error).toString()))
@@ -379,9 +372,8 @@ let FileService = class FileService extends Disposable {
     async validateWriteFile(provider, resource, options) {
         const unlock = !!options?.unlock;
         if (unlock && !(provider.capabilities & FileSystemProviderCapabilities.FileWriteUnlock)) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                6,
+            throw ( (new Error(localize(
+                696,
                 "Unable to unlock file '{0}' because provider does not support it.",
                 this.resourceForError(resource)
             ))));
@@ -389,25 +381,22 @@ let FileService = class FileService extends Disposable {
         const atomic = !!options?.atomic;
         if (atomic) {
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite)) {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    7,
+                throw ( (new Error(localize(
+                    697,
                     "Unable to atomically write file '{0}' because provider does not support it.",
                     this.resourceForError(resource)
                 ))));
             }
             if (!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite)) {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    8,
+                throw ( (new Error(localize(
+                    698,
                     "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
                     this.resourceForError(resource)
                 ))));
             }
             if (unlock) {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    9,
+                throw ( (new Error(localize(
+                    699,
                     "Unable to unlock file '{0}' because atomic write is enabled.",
                     this.resourceForError(resource)
                 ))));
@@ -421,9 +410,8 @@ let FileService = class FileService extends Disposable {
             return undefined;
         }
         if ((stat.type & FileType.Directory) !== 0) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                10,
+            throw ( (new FileOperationError(localize(
+                700,
                 "Unable to write file '{0}' that is actually a directory",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_IS_DIRECTORY, options)));
@@ -433,7 +421,7 @@ let FileService = class FileService extends Disposable {
             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(_moduleId, 11, "File Modified Since"),
+                localize(701, "File Modified Since"),
                 FileOperationResult.FILE_MODIFIED_SINCE,
                 options
             )));
@@ -519,9 +507,8 @@ let FileService = class FileService extends Disposable {
         }
     }
     restoreReadError(error, resource, options) {
-        const message = ( localizeWithPath(
-            _moduleId,
-            12,
+        const message = ( localize(
+            702,
             "Unable to read file '{0}' ({1})",
             this.resourceForError(resource),
              (ensureFileSystemProviderError(error).toString())
@@ -586,24 +573,22 @@ 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(
-                _moduleId,
-                13,
+            throw ( (new FileOperationError(localize(
+                703,
                 "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(localizeWithPath(_moduleId, 14, "File not modified since"), stat, options)));
+            throw ( (new NotModifiedSinceFileOperationError(localize(704, "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(
-                _moduleId,
-                15,
+            throw ( (new TooLargeFileOperationError(localize(
+                705,
                 "Unable to read file '{0}' that is too large to open",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_TOO_LARGE, size, options)));
@@ -724,18 +709,16 @@ let FileService = class FileService extends Disposable {
                 isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    16,
+                throw ( (new Error(localize(
+                    706,
                     "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(
-                    _moduleId,
-                    17,
+                throw ( (new Error(localize(
+                    707,
                     "Unable to move/copy when source '{0}' is parent of target '{1}'.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -745,9 +728,8 @@ let FileService = class FileService extends Disposable {
         const exists = await this.exists(target);
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
-                throw ( (new FileOperationError(localizeWithPath(
-                    _moduleId,
-                    18,
+                throw ( (new FileOperationError(localize(
+                    708,
                     "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -756,9 +738,8 @@ let FileService = class FileService extends Disposable {
             if (sourceProvider === targetProvider) {
                 const { providerExtUri } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
-                    throw ( (new Error(localizeWithPath(
-                        _moduleId,
-                        19,
+                    throw ( (new Error(localize(
+                        709,
                         "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.",
                         this.resourceForError(source),
                         this.resourceForError(target)
@@ -802,26 +783,23 @@ let FileService = class FileService extends Disposable {
         const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
         const useTrash = !!options?.useTrash;
         if (useTrash && !(provider.capabilities & FileSystemProviderCapabilities.Trash)) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                20,
+            throw ( (new Error(localize(
+                710,
                 "Unable to delete file '{0}' via trash because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         const atomic = options?.atomic;
         if (atomic && !(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete)) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                21,
+            throw ( (new Error(localize(
+                711,
                 "Unable to delete file '{0}' atomically because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (useTrash && atomic) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                22,
+            throw ( (new Error(localize(
+                712,
                 "Unable to atomically delete file '{0}' because using trash is enabled.",
                 this.resourceForError(resource)
             ))));
@@ -836,9 +814,8 @@ let FileService = class FileService extends Disposable {
             this.throwIfFileIsReadonly(resource, stat);
         }
         else {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                23,
+            throw ( (new FileOperationError(localize(
+                713,
                 "Unable to delete nonexistent file '{0}'",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_NOT_FOUND)));
@@ -847,9 +824,8 @@ let FileService = class FileService extends Disposable {
         if (!recursive) {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
-                throw ( (new Error(localizeWithPath(
-                    _moduleId,
-                    24,
+                throw ( (new Error(localize(
+                    714,
                     "Unable to delete non-empty folder '{0}'.",
                     this.resourceForError(resource)
                 ))));
@@ -1109,9 +1085,8 @@ let FileService = class FileService extends Disposable {
     }
     throwIfFileSystemIsReadonly(provider, resource) {
         if (provider.capabilities & FileSystemProviderCapabilities.Readonly) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                25,
+            throw ( (new FileOperationError(localize(
+                715,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_PERMISSION_DENIED)));
@@ -1120,9 +1095,8 @@ let FileService = class FileService extends Disposable {
     }
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
-            throw ( (new FileOperationError(localizeWithPath(
-                _moduleId,
-                25,
+            throw ( (new FileOperationError(localize(
+                715,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
             ), FileOperationResult.FILE_PERMISSION_DENIED)));

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

@@ -1,9 +1,8 @@
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { canceled } from 'vscode/vscode/vs/base/common/errors';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { ensureFileSystemProviderError, createFileSystemProviderError, FileSystemProviderErrorCode } from 'vscode/vscode/vs/platform/files/common/files';
 
-const _moduleId = "vs/platform/files/common/io";
 async function readFileIntoStream(provider, resource, target, transformer, options, token) {
     let error = undefined;
     try {
@@ -70,7 +69,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localizeWithPath(_moduleId, 0, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(localize(4050, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { TextFileEditorModelState, TextFileOperationError, TextFileOperationResult, toBufferOrReadable, stringToSnapshot } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
@@ -51,11 +51,10 @@ import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 
 var AbstractTextFileService_1;
-const _moduleId = "vs/workbench/services/textfile/browser/textFileService";
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     static { AbstractTextFileService_1 = this; }
-    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localizeWithPath(_moduleId, 0, "File Created"))); }
-    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localizeWithPath(_moduleId, 1, "File Replaced"))); }
+    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(4051, "File Created"))); }
+    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(4052, "File Replaced"))); }
     constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
         super();
         this.fileService = fileService;
@@ -85,7 +84,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localizeWithPath(_moduleId, 2, "Text File Model Decorations"));
+                this.label = ( localize(4053, "Text File Model Decorations"));
                 this._onDidChange = this._register(( (new Emitter())));
                 this.onDidChange = this._onDidChange.event;
                 this.registerListeners();
@@ -112,20 +111,20 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localizeWithPath(_moduleId, 3, "Deleted, Read-only")),
+                        tooltip: ( localize(4054, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localizeWithPath(_moduleId, 4, "Read-only")),
+                        tooltip: ( localize(4055, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localizeWithPath(_moduleId, 5, "Deleted")),
+                        tooltip: ( localize(4056, "Deleted")),
                     };
                 }
                 return undefined;
@@ -179,7 +178,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             cts.dispose(true);
             if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
                 throw ( (new TextFileOperationError(
-                    localizeWithPath(_moduleId, 6, "File seems to be binary and cannot be opened as text"),
+                    localize(4057, "File seems to be binary and cannot be opened as text"),
                     TextFileOperationResult.FILE_IS_BINARY,
                     options
                 )));
@@ -396,34 +395,31 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     async confirmOverwrite(resource) {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
-            message: ( localizeWithPath(
-                _moduleId,
-                7,
+            message: ( localize(
+                4058,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
-            detail: ( localizeWithPath(
-                _moduleId,
-                8,
+            detail: ( localize(
+                4059,
                 "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: ( localizeWithPath(_moduleId, 9, "&&Replace")),
+            primaryButton: ( localize(4060, "&&Replace")),
         });
         return confirmed;
     }
     async confirmMakeWriteable(resource) {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
-            message: ( localizeWithPath(
-                _moduleId,
-                10,
+            message: ( localize(
+                4061,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localizeWithPath(_moduleId, 11, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localizeWithPath(_moduleId, 12, "&&Save Anyway"))
+            detail: ( localize(4062, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(4063, "&&Save Anyway"))
         });
         return confirmed;
     }

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

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -19,7 +19,6 @@ import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/com
 import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 
-const _moduleId = "vs/workbench/services/textfile/common/textFileEditorModelManager";
 let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
     get models() {
         return [...( (this.mapResourceToModel.values()))];
@@ -62,9 +61,8 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
             const notificationService = this.notificationService;
             return {
                 onSaveError(error, model) {
-                    notificationService.error(( localizeWithPath(
-                        _moduleId,
-                        0,
+                    notificationService.error(( localize(
+                        9510,
                         "Failed to save '{0}': {1}",
                         model.name,
                         toErrorMessage(error, false)