@codingame/monaco-vscode-api 31.0.1 → 32.0.1

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

@@ -35,11 +35,11 @@ function createValidator(prop) {
             }
         }
         if (prop.type === "boolean" && value !== true && value !== false) {
-            errors.push(( localize(16514, "Incorrect type. Expected \"boolean\".")));
+            errors.push(( localize(16848, "Incorrect type. Expected \"boolean\".")));
         }
         if (isNumeric) {
             if (isNullOrEmpty(value) || typeof value === "boolean" || Array.isArray(value) || isNaN(+value)) {
-                errors.push(( localize(16515, "Value must be a number.")));
+                errors.push(( localize(16849, "Value must be a number.")));
             } else {
                 errors.push(...( numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message)));
             }
@@ -47,11 +47,11 @@ function createValidator(prop) {
         if (prop.type === "string") {
             if (prop.enum && !isStringArray(prop.enum)) {
                 errors.push(( localize(
-                    16516,
+                    16850,
                     "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(16517, "Incorrect type. Expected \"string\".")));
+                errors.push(( localize(16851, "Incorrect type. Expected \"string\".")));
             } else {
                 errors.push(...( stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message)));
             }
@@ -69,7 +69,7 @@ function getInvalidTypeError(value, type) {
     const typeArr = Array.isArray(type) ? type : [type];
     if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
         return localize(
-            16518,
+            16852,
             "Setting has an invalid type, expected {0}. Fix in JSON.",
             JSON.stringify(type)
         );
@@ -101,7 +101,7 @@ function toRegExp(pattern) {
             return ( new RegExp(pattern));
         } catch (e) {
             console.error(( localize(
-                16519,
+                16853,
                 "Error parsing the following regex both with and without the u flag:"
             )), pattern);
             return /.*/;
@@ -117,41 +117,41 @@ function getStringValidators(prop) {
     return [{
         enabled: prop.maxLength !== undefined,
         isValid: (value => value.length <= prop.maxLength),
-        message: ( localize(16520, "Value must be {0} or fewer characters long.", prop.maxLength))
+        message: ( localize(16854, "Value must be {0} or fewer characters long.", prop.maxLength))
     }, {
         enabled: prop.minLength !== undefined,
         isValid: (value => value.length >= prop.minLength),
-        message: ( localize(16521, "Value must be {0} or more characters long.", prop.minLength))
+        message: ( localize(16855, "Value must be {0} or more characters long.", prop.minLength))
     }, {
         enabled: patternRegex !== undefined,
         isValid: (value => patternRegex.test(value)),
-        message: prop.patternErrorMessage || ( localize(16522, "Value must match regex `{0}`.", prop.pattern))
+        message: prop.patternErrorMessage || ( localize(16856, "Value must match regex `{0}`.", prop.pattern))
     }, {
         enabled: prop.format === "color-hex",
         isValid: (value => Color.Format.CSS.parseHex(value)),
-        message: ( localize(16523, "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."))
+        message: ( localize(16857, "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."))
     }, {
         enabled: prop.format === "uri" || prop.format === "uri-reference",
         isValid: (value => !!value.length),
-        message: ( localize(16524, "URI expected."))
+        message: ( localize(16858, "URI expected."))
     }, {
         enabled: prop.format === "uri" || prop.format === "uri-reference",
         isValid: (value => uriRegex.test(value)),
-        message: ( localize(16525, "URI is expected."))
+        message: ( localize(16859, "URI is expected."))
     }, {
         enabled: prop.format === "uri",
         isValid: (value => {
             const matches = value.match(uriRegex);
             return !!(matches && matches[2]);
         }),
-        message: ( localize(16526, "URI with a scheme is expected."))
+        message: ( localize(16860, "URI with a scheme is expected."))
     }, {
         enabled: prop.enum !== undefined,
         isValid: (value => {
             return prop.enum.includes(value);
         }),
         message: ( localize(
-            16527,
+            16861,
             "Value is not accepted. Valid values: {0}.",
             prop.enum ? ( prop.enum.map(key => `"${key}"`)).join(", ") : "[]"
         ))
@@ -180,27 +180,27 @@ function getNumericValidators(prop) {
     return [{
         enabled: exclusiveMax !== undefined && (prop.maximum === undefined || exclusiveMax <= prop.maximum),
         isValid: (value => value < exclusiveMax),
-        message: ( localize(16528, "Value must be strictly less than {0}.", exclusiveMax))
+        message: ( localize(16862, "Value must be strictly less than {0}.", exclusiveMax))
     }, {
         enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
         isValid: (value => value > exclusiveMin),
-        message: ( localize(16529, "Value must be strictly greater than {0}.", exclusiveMin))
+        message: ( localize(16863, "Value must be strictly greater than {0}.", exclusiveMin))
     }, {
         enabled: prop.maximum !== undefined && (exclusiveMax === undefined || exclusiveMax > prop.maximum),
         isValid: (value => value <= prop.maximum),
-        message: ( localize(16530, "Value must be less than or equal to {0}.", prop.maximum))
+        message: ( localize(16864, "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(16531, "Value must be greater than or equal to {0}.", prop.minimum))
+        message: ( localize(16865, "Value must be greater than or equal to {0}.", prop.minimum))
     }, {
         enabled: prop.multipleOf !== undefined,
         isValid: (value => value % prop.multipleOf === 0),
-        message: ( localize(16532, "Value must be a multiple of {0}.", prop.multipleOf))
+        message: ( localize(16866, "Value must be a multiple of {0}.", prop.multipleOf))
     }, {
         enabled: isIntegral,
         isValid: (value => value % 1 === 0),
-        message: ( localize(16533, "Value must be an integer."))
+        message: ( localize(16867, "Value must be an integer."))
     }].filter(validation => validation.enabled);
 }
 function getArrayValidator(prop) {
@@ -214,28 +214,28 @@ function getArrayValidator(prop) {
                 }
                 let message = "";
                 if (!Array.isArray(value)) {
-                    message += ( localize(16534, "Incorrect type. Expected an array."));
+                    message += ( localize(16868, "Incorrect type. Expected an array."));
                     message += "\n";
                     return message;
                 }
                 const arrayValue = value;
                 if (prop.uniqueItems) {
                     if (( new Set(arrayValue)).size < arrayValue.length) {
-                        message += ( localize(16535, "Array has duplicate items"));
+                        message += ( localize(16869, "Array has duplicate items"));
                         message += "\n";
                     }
                 }
                 if (prop.minItems && arrayValue.length < prop.minItems) {
-                    message += ( localize(16536, "Array must have at least {0} items", prop.minItems));
+                    message += ( localize(16870, "Array must have at least {0} items", prop.minItems));
                     message += "\n";
                 }
                 if (prop.maxItems && arrayValue.length > prop.maxItems) {
-                    message += ( localize(16537, "Array must have at most {0} items", prop.maxItems));
+                    message += ( localize(16871, "Array must have at most {0} items", prop.maxItems));
                     message += "\n";
                 }
                 if (propItems.type === "string") {
                     if (!isStringArray(arrayValue)) {
-                        message += ( localize(16538, "Incorrect type. Expected a string array."));
+                        message += ( localize(16872, "Incorrect type. Expected a string array."));
                         message += "\n";
                         return message;
                     }
@@ -244,7 +244,7 @@ function getArrayValidator(prop) {
                         arrayValue.forEach(v => {
                             if (!patternRegex.test(v)) {
                                 message += propItems.patternErrorMessage || ( localize(
-                                    16539,
+                                    16873,
                                     "Value {0} must match regex {1}.",
                                     withQuotes(v),
                                     withQuotes(propItems.pattern)
@@ -257,7 +257,7 @@ function getArrayValidator(prop) {
                         arrayValue.forEach(v => {
                             if (propItemsEnum.indexOf(v) === -1) {
                                 message += ( localize(
-                                    16540,
+                                    16874,
                                     "Value {0} is not one of {1}",
                                     withQuotes(v),
                                     "[" + ( propItemsEnum.map(withQuotes)).join(", ") + "]"
@@ -295,14 +295,14 @@ function getObjectValidator(prop) {
             const errors = [];
             let propertyNamesErrorShown = false;
             if (!isObject(value)) {
-                errors.push(( localize(16541, "Incorrect type. Expected an object.")));
+                errors.push(( localize(16875, "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(16542, "Property name must match pattern `{0}`.", propertyNames.pattern));
+                            const errorMessage = propertyNames.patternErrorMessage || ( localize(16876, "Property name must match pattern `{0}`.", propertyNames.pattern));
                             errors.push(errorMessage + "\n");
                             propertyNamesErrorShown = true;
                         }
@@ -326,7 +326,7 @@ function getObjectValidator(prop) {
                         }
                     }
                     if (additionalProperties === false) {
-                        errors.push(( localize(16543, "Property {0} is not allowed.\n", key)));
+                        errors.push(( localize(16877, "Property {0} is not allowed.\n", key)));
                     } else if (typeof additionalProperties === "object") {
                         const errorMessage = getErrorsForSchema(additionalProperties, data);
                         if (errorMessage) {

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

@@ -38,7 +38,7 @@ const getStartedWalkthrough = {
     required: ["id"],
     properties: {
         id: {
-            description: ( localize(16553, "The ID of a Get Started walkthrough to open.")),
+            description: ( localize(16887, "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(16554, "Contributes help information for Remote")),
+        description: ( localize(16888, "Contributes help information for Remote")),
         type: "object",
         properties: {
             "getStarted": {
                 description: ( localize(
-                    16555,
+                    16889,
                     "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(
-                    16556,
+                    16890,
                     "The url, or a command that returns the url, to your project's documentation page"
                 )),
                 type: "string"
             },
             "feedback": {
                 description: ( localize(
-                    16557,
+                    16891,
                     "The url, or a command that returns the url, to your project's feedback reporter"
                 )),
                 type: "string",
-                markdownDeprecationMessage: ( localize(16558, "Use {0} instead", "`reportIssue`"))
+                markdownDeprecationMessage: ( localize(16892, "Use {0} instead", "`reportIssue`"))
             },
             "reportIssue": {
                 description: ( localize(
-                    16559,
+                    16893,
                     "The url, or a command that returns the url, to your project's issue reporter"
                 )),
                 type: "string"
             },
             "issues": {
                 description: ( localize(
-                    16560,
+                    16894,
                     "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(16561, "Whether the Ports view is enabled."))));
-const forwardedPortsViewEnabled = ( new RawContextKey("forwardedPortsViewOnlyEnabled", false, ( localize(16561, "Whether the Ports view is enabled."))));
+const forwardedPortsFeaturesEnabled = ( new RawContextKey("forwardedPortsViewEnabled", false, ( localize(16895, "Whether the Ports view is enabled."))));
+const forwardedPortsViewEnabled = ( new RawContextKey("forwardedPortsViewOnlyEnabled", false, ( localize(16895, "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(16562, "User Forwarded"))
+    description: ( localize(16896, "User Forwarded"))
 };
 const AutoTunnelSource = {
     source: TunnelSource.Auto,
-    description: ( localize(16563, "Auto Forwarded"))
+    description: ( localize(16897, "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(
-            16564,
+            16898,
             "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(16565, "Statically Forwarded"))
+                        description: ( localize(16899, "Statically Forwarded"))
                     }
                 });
                 this.tunnelService.setEnvironmentTunnel(

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

@@ -73,12 +73,17 @@ class IgnoreFile {
             if (!(this.ignoreCase ? startsWithIgnoreCase(path, dirPath) : path.startsWith(dirPath))) {
                 return false;
             }
-            if (isDir && isDirIgnored(path) && !isDirIncluded(path)) {
+            const dirIncluded = isDir && isDirIncluded(path);
+            if (isDir && isDirIgnored(path) && !dirIncluded) {
                 return true;
             }
-            if (isFileIgnored(path) && !isFileIncluded(path)) {
+            const fileIncluded = isFileIncluded(path);
+            if (isFileIgnored(path) && !fileIncluded) {
                 return true;
             }
+            if (dirIncluded || fileIncluded) {
+                return false;
+            }
             if (parent) {
                 return parent.isPathIgnored(path, isDir);
             }

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

@@ -56,7 +56,7 @@ let QueryBuilder = class QueryBuilder {
             const folderConfig = this.configurationService.getValue({
                 resource: folder
             });
-            return !folderConfig.search.useRipgrep;
+            return !folderConfig.search?.useRipgrep;
         }));
         const commonQuery = this.commonQuery(folderResources?.map(toWorkspaceFolder), options);
         return {
@@ -65,7 +65,7 @@ let QueryBuilder = class QueryBuilder {
             contentPattern,
             previewOptions: options.previewOptions,
             maxFileSize: options.maxFileSize,
-            usePCRE2: searchConfig.search.usePCRE2 || fallbackToPCRE || false,
+            usePCRE2: searchConfig.search?.usePCRE2 || fallbackToPCRE || false,
             surroundingContext: options.surroundingContext,
             userDisabledExcludesAndIgnoreFiles: options.disregardExcludeSettings && options.disregardIgnoreFiles
         };
@@ -372,7 +372,7 @@ let QueryBuilder = class QueryBuilder {
             } else {
                 const probableWorkspaceFolderNameMatch = searchPath.match(/\.[\/\\](.+)[\/\\]?/);
                 const probableWorkspaceFolderName = probableWorkspaceFolderNameMatch ? probableWorkspaceFolderNameMatch[1] : searchPath;
-                const searchPathNotFoundError = ( localize(16569, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
+                const searchPathNotFoundError = ( localize(16903, "Workspace folder does not exist: {0}", probableWorkspaceFolderName));
                 throw ( new Error(searchPathNotFoundError));
             }
         }

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

@@ -292,7 +292,7 @@ export interface ISearchConfigurationProperties {
     };
 }
 export interface ISearchConfiguration extends IFilesConfiguration {
-    search: ISearchConfigurationProperties;
+    search?: ISearchConfigurationProperties;
     editor: {
         wordSeparators: string;
     };

package/vscode/src/vs/workbench/services/storage/browser/storageService.d.ts

@@ -14,6 +14,8 @@ export declare class BrowserStorageService extends AbstractStorageService {
     private applicationStorageDatabase;
     private readonly applicationStoragePromise;
     private readonly applicationStorageDisposables;
+    private applicationSharedStorage;
+    private applicationSharedStorageDatabase;
     private profileStorage;
     private profileStorageDatabase;
     private profileStorageProfile;
@@ -27,6 +29,7 @@ export declare class BrowserStorageService extends AbstractStorageService {
     protected doInitialize(): Promise<void>;
     private createApplicationStorage;
     protected createApplicationStorageDatabase(disposableStore: DisposableStore): Promise<IStorageDatabase>;
+    private createApplicationSharedStorage;
     private createProfileStorage;
     protected createProfileStorageDatabase(profile: IUserDataProfile, disposableStore: DisposableStore): Promise<IStorageDatabase>;
     private createWorkspaceStorage;
@@ -63,6 +66,7 @@ interface IndexedDBStorageDatabaseOptions {
 export declare class IndexedDBStorageDatabase extends Disposable implements IIndexedDBStorageDatabase {
     private readonly logService;
     static createApplicationStorage(logService: ILogService): Promise<IIndexedDBStorageDatabase>;
+    static createApplicationSharedStorage(logService: ILogService): Promise<IIndexedDBStorageDatabase>;
     static createProfileStorage(profile: IUserDataProfile, logService: ILogService): Promise<IIndexedDBStorageDatabase>;
     static createWorkspaceStorage(workspaceId: string, logService: ILogService): Promise<IIndexedDBStorageDatabase>;
     static create(options: IndexedDBStorageDatabaseOptions, logService: ILogService): Promise<IIndexedDBStorageDatabase>;

package/vscode/src/vs/workbench/services/storage/browser/storageService.js

@@ -30,7 +30,7 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
     }
     get hasPendingUpdate() {
         return Boolean(
-            getIIndexedDBStorageDatabase(this.applicationStorageDatabase)?.hasPendingUpdate || getIIndexedDBStorageDatabase(this.profileStorageDatabase)?.hasPendingUpdate || getIIndexedDBStorageDatabase(this.workspaceStorageDatabase)?.hasPendingUpdate
+            getIIndexedDBStorageDatabase(this.applicationStorageDatabase)?.hasPendingUpdate || getIIndexedDBStorageDatabase(this.applicationSharedStorageDatabase)?.hasPendingUpdate || getIIndexedDBStorageDatabase(this.profileStorageDatabase)?.hasPendingUpdate || getIIndexedDBStorageDatabase(this.workspaceStorageDatabase)?.hasPendingUpdate
         );
     }
     constructor(workspace, userDataProfileService, logService) {
@@ -55,6 +55,7 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
     async doInitialize() {
         await Promises.settled([
             this.createApplicationStorage(),
+            this.createApplicationSharedStorage(),
             this.createProfileStorage(this.profileStorageProfile),
             this.createWorkspaceStorage()
         ]);
@@ -76,6 +77,16 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
         const applicationStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationStorage(this.logService);
         return disposableStore.add(applicationStorageIndexedDB);
     }
+    async createApplicationSharedStorage() {
+        const applicationSharedStorageIndexedDB = await IndexedDBStorageDatabase.createApplicationSharedStorage(this.logService);
+        this.applicationSharedStorageDatabase = this._register(applicationSharedStorageIndexedDB);
+        this.applicationSharedStorage = this._register(( new Storage(this.applicationSharedStorageDatabase)));
+        this._register(
+            this.applicationSharedStorage.onDidChangeStorage(e => this.emitDidChangeValue(StorageScope.APPLICATION_SHARED, e))
+        );
+        await this.applicationSharedStorage.init();
+        this.updateIsNew(this.applicationSharedStorage);
+    }
     async createProfileStorage(profile) {
         this.profileStorageDisposables.clear();
         this.profileStorageProfile = profile;
@@ -127,6 +138,8 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
     }
     getStorage(scope) {
         switch (scope) {
+        case StorageScope.APPLICATION_SHARED:
+            return this.applicationSharedStorage;
         case StorageScope.APPLICATION:
             return this.applicationStorage;
         case StorageScope.PROFILE:
@@ -137,6 +150,8 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
     }
     getLogDetails(scope) {
         switch (scope) {
+        case StorageScope.APPLICATION_SHARED:
+            return this.applicationSharedStorageDatabase?.name;
         case StorageScope.APPLICATION:
             return getIIndexedDBStorageDatabase(this.applicationStorageDatabase)?.name;
         case StorageScope.PROFILE:
@@ -175,13 +190,19 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
     close() {
         if (isSafari) {
             this.applicationStorage?.close();
+            this.applicationSharedStorageDatabase?.close();
             this.profileStorageDatabase?.close();
             this.workspaceStorageDatabase?.close();
         }
         this.dispose();
     }
     async clear() {
-        for (const scope of [StorageScope.APPLICATION, StorageScope.PROFILE, StorageScope.WORKSPACE]) {
+        for (const scope of [
+            StorageScope.APPLICATION,
+            StorageScope.APPLICATION_SHARED,
+            StorageScope.PROFILE,
+            StorageScope.WORKSPACE
+        ]) {
             for (const target of [StorageTarget.USER, StorageTarget.MACHINE]) {
                 for (const key of ( this.keys(scope, target))) {
                     this.remove(key, scope);
@@ -191,6 +212,7 @@ let BrowserStorageService = class BrowserStorageService extends AbstractStorageS
         }
         await Promises.settled([
             getIIndexedDBStorageDatabase(this.applicationStorageDatabase)?.clear() ?? Promise.resolve(),
+            getIIndexedDBStorageDatabase(this.applicationSharedStorageDatabase)?.clear() ?? Promise.resolve(),
             getIIndexedDBStorageDatabase(this.profileStorageDatabase)?.clear() ?? Promise.resolve(),
             getIIndexedDBStorageDatabase(this.workspaceStorageDatabase)?.clear() ?? Promise.resolve()
         ]);
@@ -221,6 +243,12 @@ class IndexedDBStorageDatabase extends Disposable {
             broadcastChanges: true
         }, logService);
     }
+    static async createApplicationSharedStorage(logService) {
+        return IndexedDBStorageDatabase.create({
+            id: "global-shared",
+            broadcastChanges: true
+        }, logService);
+    }
     static async createProfileStorage(profile, logService) {
         return IndexedDBStorageDatabase.create({
             id: `global-${profile.id}`,

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(16595, "Contributes textmate tokenizers.")),
+        description: ( localize(16929, "Contributes textmate tokenizers.")),
         type: "array",
         defaultSnippets: [{
             body: [{
@@ -27,29 +27,29 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
             }],
             properties: {
                 language: {
-                    description: ( localize(16596, "Language identifier for which this syntax is contributed to.")),
+                    description: ( localize(16930, "Language identifier for which this syntax is contributed to.")),
                     type: "string"
                 },
                 scopeName: {
-                    description: ( localize(16597, "Textmate scope name used by the tmLanguage file.")),
+                    description: ( localize(16931, "Textmate scope name used by the tmLanguage file.")),
                     type: "string"
                 },
                 path: {
                     description: ( localize(
-                        16598,
+                        16932,
                         "Path of the tmLanguage file. The path is relative to the extension folder and typically starts with './syntaxes/'."
                     )),
                     type: "string"
                 },
                 embeddedLanguages: {
                     description: ( localize(
-                        16599,
+                        16933,
                         "A map of scope name to language id if this grammar contains embedded languages."
                     )),
                     type: "object"
                 },
                 tokenTypes: {
-                    description: ( localize(16600, "A map of scope name to token types.")),
+                    description: ( localize(16934, "A map of scope name to token types.")),
                     type: "object",
                     additionalProperties: {
                         enum: ["string", "comment", "other", "regex"]
@@ -57,7 +57,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 injectTo: {
                     description: ( localize(
-                        16601,
+                        16935,
                         "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(16602, "Defines which scope names contain balanced brackets.")),
+                    description: ( localize(16936, "Defines which scope names contain balanced brackets.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -74,7 +74,7 @@ const grammarsExtPoint = ExtensionsRegistry.registerExtensionPoint({
                     default: ["*"]
                 },
                 unbalancedBracketScopes: {
-                    description: ( localize(16603, "Defines which scope names do not contain balanced brackets.")),
+                    description: ( localize(16937, "Defines which scope names do not contain balanced brackets.")),
                     type: "array",
                     items: {
                         type: "string"