@codingame/monaco-vscode-api 28.4.0 → 29.0.0

package/vscode/src/vs/workbench/services/preferences/common/preferencesValidation.d.ts

@@ -0,0 +1,11 @@
+import { IConfigurationPropertySchema } from "../../../../platform/configuration/common/configurationRegistry.js";
+export declare function createValidator(prop: IConfigurationPropertySchema): (value: any) => (string | null);
+/**
+ * Returns an error string if the value is invalid and can't be displayed in the settings UI for the given type.
+ */
+export declare function getInvalidTypeError(value: any, type: undefined | string | string[]): string | undefined;
+/**
+ * Validates a single property name against the propertyNames.pattern schema.
+ * Returns true if the key is valid, false otherwise.
+ */
+export declare function validatePropertyName(propertyNames: IConfigurationPropertySchema["propertyNames"], key: string): boolean;

package/vscode/src/vs/workbench/services/preferences/common/preferencesValidation.js

@@ -0,0 +1,359 @@
+
+import { localize } from '../../../../nls.js';
+import { Color } from '../../../../base/common/color.js';
+import { isUndefinedOrNull, isStringArray, isString, isObject } from '../../../../base/common/types.js';
+
+function canBeType(propTypes, ...types) {
+    return ( types.some(t => propTypes.includes(t)));
+}
+function isNullOrEmpty(value) {
+    return value === "" || isUndefinedOrNull(value);
+}
+function createValidator(prop) {
+    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
+    const isNullable = canBeType(type, "null");
+    const isNumeric = (canBeType(type, "number") || canBeType(type, "integer")) && (type.length === 1 || type.length === 2 && isNullable);
+    const numericValidations = getNumericValidators(prop);
+    const stringValidations = getStringValidators(prop);
+    const arrayValidator = getArrayValidator(prop);
+    const objectValidator = getObjectValidator(prop);
+    return value => {
+        if (isNullable && isNullOrEmpty(value)) {
+            return "";
+        }
+        const errors = [];
+        if (arrayValidator) {
+            const err = arrayValidator(value);
+            if (err) {
+                errors.push(err);
+            }
+        }
+        if (objectValidator) {
+            const err = objectValidator(value);
+            if (err) {
+                errors.push(err);
+            }
+        }
+        if (prop.type === "boolean" && value !== true && value !== false) {
+            errors.push(( localize(16211, "Incorrect type. Expected \"boolean\".")));
+        }
+        if (isNumeric) {
+            if (isNullOrEmpty(value) || typeof value === "boolean" || Array.isArray(value) || isNaN(+value)) {
+                errors.push(( localize(16212, "Value must be a number.")));
+            } else {
+                errors.push(...( numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message)));
+            }
+        }
+        if (prop.type === "string") {
+            if (prop.enum && !isStringArray(prop.enum)) {
+                errors.push(( localize(
+                    16213,
+                    "The enum options should be strings, but there is a non-string option. Please file an issue with the extension author."
+                )));
+            } else if (!isString(value)) {
+                errors.push(( localize(16214, "Incorrect type. Expected \"string\".")));
+            } else {
+                errors.push(...( stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message)));
+            }
+        }
+        if (errors.length) {
+            return prop.errorMessage ? [prop.errorMessage, ...errors].join(" ") : errors.join(" ");
+        }
+        return "";
+    };
+}
+function getInvalidTypeError(value, type) {
+    if (typeof type === "undefined") {
+        return;
+    }
+    const typeArr = Array.isArray(type) ? type : [type];
+    if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
+        return localize(
+            16215,
+            "Setting has an invalid type, expected {0}. Fix in JSON.",
+            JSON.stringify(type)
+        );
+    }
+    return;
+}
+function valueValidatesAsType(value, type) {
+    const valueType = typeof value;
+    if (type === "boolean") {
+        return valueType === "boolean";
+    } else if (type === "object") {
+        return value && !Array.isArray(value) && valueType === "object";
+    } else if (type === "null") {
+        return value === null;
+    } else if (type === "array") {
+        return Array.isArray(value);
+    } else if (type === "string") {
+        return valueType === "string";
+    } else if (type === "number" || type === "integer") {
+        return valueType === "number";
+    }
+    return true;
+}
+function toRegExp(pattern) {
+    try {
+        return ( new RegExp(pattern, "u"));
+    } catch (e) {
+        try {
+            return ( new RegExp(pattern));
+        } catch (e) {
+            console.error(( localize(
+                16216,
+                "Error parsing the following regex both with and without the u flag:"
+            )), pattern);
+            return /.*/;
+        }
+    }
+}
+function getStringValidators(prop) {
+    const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+    let patternRegex;
+    if (typeof prop.pattern === "string") {
+        patternRegex = toRegExp(prop.pattern);
+    }
+    return [{
+        enabled: prop.maxLength !== undefined,
+        isValid: (value => value.length <= prop.maxLength),
+        message: ( localize(16217, "Value must be {0} or fewer characters long.", prop.maxLength))
+    }, {
+        enabled: prop.minLength !== undefined,
+        isValid: (value => value.length >= prop.minLength),
+        message: ( localize(16218, "Value must be {0} or more characters long.", prop.minLength))
+    }, {
+        enabled: patternRegex !== undefined,
+        isValid: (value => patternRegex.test(value)),
+        message: prop.patternErrorMessage || ( localize(16219, "Value must match regex `{0}`.", prop.pattern))
+    }, {
+        enabled: prop.format === "color-hex",
+        isValid: (value => Color.Format.CSS.parseHex(value)),
+        message: ( localize(16220, "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."))
+    }, {
+        enabled: prop.format === "uri" || prop.format === "uri-reference",
+        isValid: (value => !!value.length),
+        message: ( localize(16221, "URI expected."))
+    }, {
+        enabled: prop.format === "uri" || prop.format === "uri-reference",
+        isValid: (value => uriRegex.test(value)),
+        message: ( localize(16222, "URI is expected."))
+    }, {
+        enabled: prop.format === "uri",
+        isValid: (value => {
+            const matches = value.match(uriRegex);
+            return !!(matches && matches[2]);
+        }),
+        message: ( localize(16223, "URI with a scheme is expected."))
+    }, {
+        enabled: prop.enum !== undefined,
+        isValid: (value => {
+            return prop.enum.includes(value);
+        }),
+        message: ( localize(
+            16224,
+            "Value is not accepted. Valid values: {0}.",
+            prop.enum ? ( prop.enum.map(key => `"${key}"`)).join(", ") : "[]"
+        ))
+    }].filter(validation => validation.enabled);
+}
+function getNumericValidators(prop) {
+    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
+    const isNullable = canBeType(type, "null");
+    const isIntegral = (canBeType(type, "integer")) && (type.length === 1 || type.length === 2 && isNullable);
+    const isNumeric = canBeType(type, "number", "integer") && (type.length === 1 || type.length === 2 && isNullable);
+    if (!isNumeric) {
+        return [];
+    }
+    let exclusiveMax;
+    let exclusiveMin;
+    if (typeof prop.exclusiveMaximum === "boolean") {
+        exclusiveMax = prop.exclusiveMaximum ? prop.maximum : undefined;
+    } else {
+        exclusiveMax = prop.exclusiveMaximum;
+    }
+    if (typeof prop.exclusiveMinimum === "boolean") {
+        exclusiveMin = prop.exclusiveMinimum ? prop.minimum : undefined;
+    } else {
+        exclusiveMin = prop.exclusiveMinimum;
+    }
+    return [{
+        enabled: exclusiveMax !== undefined && (prop.maximum === undefined || exclusiveMax <= prop.maximum),
+        isValid: (value => value < exclusiveMax),
+        message: ( localize(16225, "Value must be strictly less than {0}.", exclusiveMax))
+    }, {
+        enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
+        isValid: (value => value > exclusiveMin),
+        message: ( localize(16226, "Value must be strictly greater than {0}.", exclusiveMin))
+    }, {
+        enabled: prop.maximum !== undefined && (exclusiveMax === undefined || exclusiveMax > prop.maximum),
+        isValid: (value => value <= prop.maximum),
+        message: ( localize(16227, "Value must be less than or equal to {0}.", prop.maximum))
+    }, {
+        enabled: prop.minimum !== undefined && (exclusiveMin === undefined || exclusiveMin < prop.minimum),
+        isValid: (value => value >= prop.minimum),
+        message: ( localize(16228, "Value must be greater than or equal to {0}.", prop.minimum))
+    }, {
+        enabled: prop.multipleOf !== undefined,
+        isValid: (value => value % prop.multipleOf === 0),
+        message: ( localize(16229, "Value must be a multiple of {0}.", prop.multipleOf))
+    }, {
+        enabled: isIntegral,
+        isValid: (value => value % 1 === 0),
+        message: ( localize(16230, "Value must be an integer."))
+    }].filter(validation => validation.enabled);
+}
+function getArrayValidator(prop) {
+    if (prop.type === "array" && prop.items && !Array.isArray(prop.items)) {
+        const propItems = prop.items;
+        if (propItems && !Array.isArray(propItems.type)) {
+            const withQuotes = s => `'` + s + `'`;
+            return value => {
+                if (!value) {
+                    return null;
+                }
+                let message = "";
+                if (!Array.isArray(value)) {
+                    message += ( localize(16231, "Incorrect type. Expected an array."));
+                    message += "\n";
+                    return message;
+                }
+                const arrayValue = value;
+                if (prop.uniqueItems) {
+                    if (( new Set(arrayValue)).size < arrayValue.length) {
+                        message += ( localize(16232, "Array has duplicate items"));
+                        message += "\n";
+                    }
+                }
+                if (prop.minItems && arrayValue.length < prop.minItems) {
+                    message += ( localize(16233, "Array must have at least {0} items", prop.minItems));
+                    message += "\n";
+                }
+                if (prop.maxItems && arrayValue.length > prop.maxItems) {
+                    message += ( localize(16234, "Array must have at most {0} items", prop.maxItems));
+                    message += "\n";
+                }
+                if (propItems.type === "string") {
+                    if (!isStringArray(arrayValue)) {
+                        message += ( localize(16235, "Incorrect type. Expected a string array."));
+                        message += "\n";
+                        return message;
+                    }
+                    if (typeof propItems.pattern === "string") {
+                        const patternRegex = toRegExp(propItems.pattern);
+                        arrayValue.forEach(v => {
+                            if (!patternRegex.test(v)) {
+                                message += propItems.patternErrorMessage || ( localize(
+                                    16236,
+                                    "Value {0} must match regex {1}.",
+                                    withQuotes(v),
+                                    withQuotes(propItems.pattern)
+                                ));
+                            }
+                        });
+                    }
+                    const propItemsEnum = propItems.enum;
+                    if (propItemsEnum) {
+                        arrayValue.forEach(v => {
+                            if (propItemsEnum.indexOf(v) === -1) {
+                                message += ( localize(
+                                    16237,
+                                    "Value {0} is not one of {1}",
+                                    withQuotes(v),
+                                    "[" + ( propItemsEnum.map(withQuotes)).join(", ") + "]"
+                                ));
+                                message += "\n";
+                            }
+                        });
+                    }
+                } else if (propItems.type === "integer" || propItems.type === "number") {
+                    arrayValue.forEach(v => {
+                        const errorMessage = getErrorsForSchema(propItems, v);
+                        if (errorMessage) {
+                            message += `${v}: ${errorMessage}\n`;
+                        }
+                    });
+                }
+                return message;
+            };
+        }
+    }
+    return null;
+}
+function getObjectValidator(prop) {
+    if (prop.type === "object") {
+        const {
+            properties,
+            patternProperties,
+            additionalProperties,
+            propertyNames
+        } = prop;
+        return value => {
+            if (!value) {
+                return null;
+            }
+            const errors = [];
+            let propertyNamesErrorShown = false;
+            if (!isObject(value)) {
+                errors.push(( localize(16238, "Incorrect type. Expected an object.")));
+            } else {
+                ( Object.keys(value)).forEach(key => {
+                    const data = value[key];
+                    if (propertyNames?.pattern && !propertyNamesErrorShown) {
+                        const patternRegex = toRegExp(propertyNames.pattern);
+                        if (!patternRegex.test(key)) {
+                            const errorMessage = propertyNames.patternErrorMessage || ( localize(16239, "Property name must match pattern `{0}`.", propertyNames.pattern));
+                            errors.push(errorMessage + "\n");
+                            propertyNamesErrorShown = true;
+                        }
+                    }
+                    if (properties && key in properties) {
+                        const errorMessage = getErrorsForSchema(properties[key], data);
+                        if (errorMessage) {
+                            errors.push(`${key}: ${errorMessage}\n`);
+                        }
+                        return;
+                    }
+                    if (patternProperties) {
+                        for (const pattern in patternProperties) {
+                            if (RegExp(pattern).test(key)) {
+                                const errorMessage = getErrorsForSchema(patternProperties[pattern], data);
+                                if (errorMessage) {
+                                    errors.push(`${key}: ${errorMessage}\n`);
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    if (additionalProperties === false) {
+                        errors.push(( localize(16240, "Property {0} is not allowed.\n", key)));
+                    } else if (typeof additionalProperties === "object") {
+                        const errorMessage = getErrorsForSchema(additionalProperties, data);
+                        if (errorMessage) {
+                            errors.push(`${key}: ${errorMessage}\n`);
+                        }
+                    }
+                });
+            }
+            if (errors.length) {
+                return prop.errorMessage ? [prop.errorMessage, ...errors].join(" ") : errors.join(" ");
+            }
+            return "";
+        };
+    }
+    return null;
+}
+function validatePropertyName(propertyNames, key) {
+    if (!propertyNames?.pattern) {
+        return true;
+    }
+    const patternRegex = toRegExp(propertyNames.pattern);
+    return patternRegex.test(key);
+}
+function getErrorsForSchema(propertySchema, data) {
+    const validator = createValidator(propertySchema);
+    const errorMessage = validator(data);
+    return errorMessage;
+}
+
+export { createValidator, getInvalidTypeError, validatePropertyName };

package/vscode/src/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -38,7 +38,7 @@ const getStartedWalkthrough = {
     required: ["id"],
     properties: {
         id: {
-            description: ( localize(15954, "The ID of a Get Started walkthrough to open.")),
+            description: ( localize(16250, "The ID of a Get Started walkthrough to open.")),
             type: "string"
         }
     }
@@ -46,12 +46,12 @@ const getStartedWalkthrough = {
 const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "remoteHelp",
     jsonSchema: {
-        description: ( localize(15955, "Contributes help information for Remote")),
+        description: ( localize(16251, "Contributes help information for Remote")),
         type: "object",
         properties: {
             "getStarted": {
                 description: ( localize(
-                    15956,
+                    16252,
                     "The url, or a command that returns the url, to your project's Getting Started page, or a walkthrough ID contributed by your project's extension"
                 )),
                 oneOf: [{
@@ -60,29 +60,29 @@ const remoteHelpExtPoint = ExtensionsRegistry.registerExtensionPoint({
             },
             "documentation": {
                 description: ( localize(
-                    15957,
+                    16253,
                     "The url, or a command that returns the url, to your project's documentation page"
                 )),
                 type: "string"
             },
             "feedback": {
                 description: ( localize(
-                    15958,
+                    16254,
                     "The url, or a command that returns the url, to your project's feedback reporter"
                 )),
                 type: "string",
-                markdownDeprecationMessage: ( localize(15959, "Use {0} instead", "`reportIssue`"))
+                markdownDeprecationMessage: ( localize(16255, "Use {0} instead", "`reportIssue`"))
             },
             "reportIssue": {
                 description: ( localize(
-                    15960,
+                    16256,
                     "The url, or a command that returns the url, to your project's issue reporter"
                 )),
                 type: "string"
             },
             "issues": {
                 description: ( localize(
-                    15961,
+                    16257,
                     "The url, or a command that returns the url, to your project's issues list"
                 )),
                 type: "string"

package/vscode/src/vs/workbench/services/remote/common/tunnelModel.js

@@ -28,8 +28,8 @@ const TUNNELS_TO_RESTORE = "remote.tunnels.toRestore";
 const TUNNELS_TO_RESTORE_EXPIRATION = "remote.tunnels.toRestoreExpiration";
 const RESTORE_EXPIRATION_TIME = 1000 * 60 * 60 * 24 * 14;
 const ACTIVATION_EVENT = "onTunnel";
-const forwardedPortsFeaturesEnabled = ( new RawContextKey("forwardedPortsViewEnabled", false, ( localize(15962, "Whether the Ports view is enabled."))));
-const forwardedPortsViewEnabled = ( new RawContextKey("forwardedPortsViewOnlyEnabled", false, ( localize(15962, "Whether the Ports view is enabled."))));
+const forwardedPortsFeaturesEnabled = ( new RawContextKey("forwardedPortsViewEnabled", false, ( localize(16258, "Whether the Ports view is enabled."))));
+const forwardedPortsViewEnabled = ( new RawContextKey("forwardedPortsViewOnlyEnabled", false, ( localize(16258, "Whether the Ports view is enabled."))));
 function parseAddress(address) {
     const matches = address.match(/^([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*:)?([0-9]+)$/);
     if (!matches) {
@@ -54,11 +54,11 @@ var TunnelSource;
 })(TunnelSource || (TunnelSource = {}));
 const UserTunnelSource = {
     source: TunnelSource.User,
-    description: ( localize(15963, "User Forwarded"))
+    description: ( localize(16259, "User Forwarded"))
 };
 const AutoTunnelSource = {
     source: TunnelSource.Auto,
-    description: ( localize(15964, "Auto Forwarded"))
+    description: ( localize(16260, "Auto Forwarded"))
 };
 function mapHasAddress(map, host, port) {
     const initialAddress = map.get(makeAddress(host, port));
@@ -596,7 +596,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         }
         this.mismatchCooldown = newCooldown;
         const mismatchString = ( localize(
-            15965,
+            16261,
             "Local port {0} could not be used for forwarding to remote port {1}.\n\nThis usually happens when there is already another process using local port {0}.\n\nPort number {2} has been used instead.",
             expectedLocal,
             tunnel.tunnelRemotePort,
@@ -785,7 +785,7 @@ let TunnelModel = class TunnelModel extends Disposable {
                     privacy: TunnelPrivacyId.ConstantPrivate,
                     source: {
                         source: TunnelSource.Extension,
-                        description: ( localize(15966, "Statically Forwarded"))
+                        description: ( localize(16262, "Statically Forwarded"))
                     }
                 });
                 this.tunnelService.setEnvironmentTunnel(

package/vscode/src/vs/workbench/services/search/common/queryBuilder.js

@@ -372,7 +372,7 @@ let QueryBuilder = class QueryBuilder {
             } else {
                 const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
                 const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
-                const searchPathNotFoundError = ( localize(15970, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
+                const searchPathNotFoundError = ( localize(16266, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
                 throw ( new Error(searchPathNotFoundError));
             }
         }

package/vscode/src/vs/workbench/services/search/common/search.d.ts

@@ -365,7 +365,7 @@ export type ISerializedSearchComplete = ISerializedSearchSuccess | ISerializedSe
 export declare function isSerializedSearchComplete(arg: ISerializedSearchProgressItem | ISerializedSearchComplete): arg is ISerializedSearchComplete;
 export declare function isSerializedSearchSuccess(arg: ISerializedSearchComplete): arg is ISerializedSearchSuccess;
 export declare function isSerializedFileMatch(arg: ISerializedSearchProgressItem): arg is ISerializedFileMatch;
-export declare function isFilePatternMatch(candidate: IRawFileMatch, filePatternToUse: string, fuzzy?: boolean): boolean;
+export declare function isFilePatternMatch(candidate: IRawFileMatch, filePatternToUse: string, fuzzy?: boolean, ignoreCase?: boolean): boolean;
 export interface ISerializedFileMatch {
     path: string;
     results?: ITextSearchResult[];

package/vscode/src/vs/workbench/services/textMate/common/TMGrammars.js

@@ -7,7 +7,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "grammars",
     deps: [languagesExtPoint],
     jsonSchema: {
-        description: ( localize(15996, "Contributes textmate tokenizers.")),
+        description: ( localize(16292, "Contributes textmate tokenizers.")),
         type: "array",
         defaultSnippets: [{
             body: [{
@@ -27,29 +27,29 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
             }],
             properties: {
                 language: {
-                    description: ( localize(15997, "Language identifier for which this syntax is contributed to.")),
+                    description: ( localize(16293, "Language identifier for which this syntax is contributed to.")),
                     type: "string"
                 },
                 scopeName: {
-                    description: ( localize(15998, "Textmate scope name used by the tmLanguage file.")),
+                    description: ( localize(16294, "Textmate scope name used by the tmLanguage file.")),
                     type: "string"
                 },
                 path: {
                     description: ( localize(
-                        15999,
+                        16295,
                         "Path of the tmLanguage file. The path is relative to the extension folder and typically starts with './syntaxes/'."
                     )),
                     type: "string"
                 },
                 embeddedLanguages: {
                     description: ( localize(
-                        16000,
+                        16296,
                         "A map of scope name to language id if this grammar contains embedded languages."
                     )),
                     type: "object"
                 },
                 tokenTypes: {
-                    description: ( localize(16001, "A map of scope name to token types.")),
+                    description: ( localize(16297, "A map of scope name to token types.")),
                     type: "object",
                     additionalProperties: {
                         enum: ["string", "comment", "other"]
@@ -57,7 +57,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 injectTo: {
                     description: ( localize(
-                        16002,
+                        16298,
                         "List of language scope names to which this grammar is injected to."
                     )),
                     type: "array",
@@ -66,7 +66,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     }
                 },
                 balancedBracketScopes: {
-                    description: ( localize(16003, "Defines which scope names contain balanced brackets.")),
+                    description: ( localize(16299, "Defines which scope names contain balanced brackets.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -74,7 +74,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     default: ["*"]
                 },
                 unbalancedBracketScopes: {
-                    description: ( localize(16004, "Defines which scope names do not contain balanced brackets.")),
+                    description: ( localize(16300, "Defines which scope names do not contain balanced brackets.")),
                     type: "array",
                     items: {
                         type: "string"

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

@@ -40,7 +40,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         TextFileEditorModel_1 = this;
     }
     static {
-        this.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource("textFileEncoding.source", ( localize(16018, "File Encoding Changed")));
+        this.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource("textFileEncoding.source", ( localize(16314, "File Encoding Changed")));
     }
     static {
         this.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD = 500;
@@ -562,7 +562,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
         }
         const saveCancellation = ( new CancellationTokenSource());
         return this.progressService.withProgress({
-            title: ( localize(16019, "Saving '{0}'", this.name)),
+            title: ( localize(16315, "Saving '{0}'", this.name)),
             location: ProgressLocation.Window,
             cancellable: true,
             delay: this.isDirty() ? 3000 : 5000
@@ -622,7 +622,7 @@ let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel
             versionId = this.versionId;
             this.inErrorMode = false;
             progress.report({
-                message: ( localize(16020, "Writing into file..."))
+                message: ( localize(16316, "Writing into file..."))
             });
             this.trace(`doSave(${versionId}) - before write()`);
             const lastResolvedFileStat = assertReturnsDefined(this.lastResolvedFileStat);