@codingame/monaco-vscode-api 1.83.4 → 1.83.6

package/vscode/src/vs/workbench/services/themes/common/colorExtensionPoint.js

@@ -9,26 +9,46 @@ const colorIdPattern = '^\\w+[.\\w+]*$';
 const configurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'colors',
     jsonSchema: {
-        description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.color', 'Contributes extension defined themable colors'),
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/themes/common/colorExtensionPoint',
+            'contributes.color',
+            'Contributes extension defined themable colors'
+        )),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.color.id', 'The identifier of the themable color'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/colorExtensionPoint',
+                        'contributes.color.id',
+                        'The identifier of the themable color'
+                    )),
                     pattern: colorIdPattern,
-                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.color.id.format', 'Identifiers must only contain letters, digits and dots and can not start with a dot'),
+                    patternErrorMessage: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/colorExtensionPoint',
+                        'contributes.color.id.format',
+                        'Identifiers must only contain letters, digits and dots and can not start with a dot'
+                    )),
                 },
                 description: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.color.description', 'The description of the themable color'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/colorExtensionPoint',
+                        'contributes.color.description',
+                        'The description of the themable color'
+                    )),
                 },
                 defaults: {
                     type: 'object',
                     properties: {
                         light: {
-                            description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.defaults.light', 'The default color for light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'),
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/colorExtensionPoint',
+                                'contributes.defaults.light',
+                                'The default color for light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
+                            )),
                             type: 'string',
                             anyOf: [
                                 colorReferenceSchema,
@@ -36,7 +56,11 @@ const configurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
                             ]
                         },
                         dark: {
-                            description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.defaults.dark', 'The default color for dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'),
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/colorExtensionPoint',
+                                'contributes.defaults.dark',
+                                'The default color for dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default.'
+                            )),
                             type: 'string',
                             anyOf: [
                                 colorReferenceSchema,
@@ -44,7 +68,11 @@ const configurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
                             ]
                         },
                         highContrast: {
-                            description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.defaults.highContrast', 'The default color for high contrast dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `dark` color is used as default for high contrast dark themes.'),
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/colorExtensionPoint',
+                                'contributes.defaults.highContrast',
+                                'The default color for high contrast dark themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `dark` color is used as default for high contrast dark themes.'
+                            )),
                             type: 'string',
                             anyOf: [
                                 colorReferenceSchema,
@@ -52,7 +80,11 @@ const configurationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
                             ]
                         },
                         highContrastLight: {
-                            description: nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'contributes.defaults.highContrastLight', 'The default color for high contrast light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `light` color is used as default for high contrast light themes.'),
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/colorExtensionPoint',
+                                'contributes.defaults.highContrastLight',
+                                'The default color for high contrast light themes. Either a color value in hex (#RRGGBB[AA]) or the identifier of a themable color which provides the default. If not provided, the `light` color is used as default for high contrast light themes.'
+                            )),
                             type: 'string',
                             anyOf: [
                                 colorReferenceSchema,
@@ -73,7 +105,11 @@ class ColorExtensionPoint {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.colorConfiguration', "'configuration.colors' must be a array"));
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/colorExtensionPoint',
+                        'invalid.colorConfiguration',
+                        "'configuration.colors' must be a array"
+                    )));
                     return;
                 }
                 const parseColorValue = (s, name) => {
@@ -85,33 +121,62 @@ class ColorExtensionPoint {
                             return s;
                         }
                     }
-                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.default.colorType', "{0} must be either a color value in hex (#RRGGBB[AA] or #RGB[A]) or the identifier of a themable color which provides the default.", name));
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/colorExtensionPoint',
+                        'invalid.default.colorType',
+                        "{0} must be either a color value in hex (#RRGGBB[AA] or #RGB[A]) or the identifier of a themable color which provides the default.",
+                        name
+                    )));
                     return Color.red;
                 };
                 for (const colorContribution of extensionValue) {
                     if (typeof colorContribution.id !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.id', "'configuration.colors.id' must be defined and can not be empty"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.id',
+                            "'configuration.colors.id' must be defined and can not be empty"
+                        )));
                         return;
                     }
                     if (!colorContribution.id.match(colorIdPattern)) {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.id.format', "'configuration.colors.id' must only contain letters, digits and dots and can not start with a dot"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.id.format',
+                            "'configuration.colors.id' must only contain letters, digits and dots and can not start with a dot"
+                        )));
                         return;
                     }
                     if (typeof colorContribution.description !== 'string' || colorContribution.id.length === 0) {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.description', "'configuration.colors.description' must be defined and can not be empty"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.description',
+                            "'configuration.colors.description' must be defined and can not be empty"
+                        )));
                         return;
                     }
                     const defaults = colorContribution.defaults;
                     if (!defaults || typeof defaults !== 'object' || typeof defaults.light !== 'string' || typeof defaults.dark !== 'string') {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.defaults', "'configuration.colors.defaults' must be defined and must contain 'light' and 'dark'"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.defaults',
+                            "'configuration.colors.defaults' must be defined and must contain 'light' and 'dark'"
+                        )));
                         return;
                     }
                     if (defaults.highContrast && typeof defaults.highContrast !== 'string') {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.defaults.highContrast', "If defined, 'configuration.colors.defaults.highContrast' must be a string."));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.defaults.highContrast',
+                            "If defined, 'configuration.colors.defaults.highContrast' must be a string."
+                        )));
                         return;
                     }
                     if (defaults.highContrastLight && typeof defaults.highContrastLight !== 'string') {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/colorExtensionPoint', 'invalid.defaults.highContrastLight', "If defined, 'configuration.colors.defaults.highContrastLight' must be a string."));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/colorExtensionPoint',
+                            'invalid.defaults.highContrastLight',
+                            "If defined, 'configuration.colors.defaults.highContrastLight' must be a string."
+                        )));
                         return;
                     }
                     colorRegistry.registerColor(colorContribution.id, {

package/vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js

@@ -1,53 +1,4 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 const iconRegistry = ( Registry.as(Extensions.IconContribution));
-const iconReferenceSchema = iconRegistry.getIconReferenceSchema();
-const iconIdPattern = `^${ThemeIcon.iconNameSegment}(-${ThemeIcon.iconNameSegment})+$`;
-( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'icons',
-    jsonSchema: {
-        description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icons', 'Contributes extension defined themable icons'),
-        type: 'object',
-        propertyNames: {
-            pattern: iconIdPattern,
-            description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.id', 'The identifier of the themable icon'),
-            patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.id.format', 'Identifiers can only contain letters, digits and minuses and need to consist of at least two segments in the form `component-iconname`.'),
-        },
-        additionalProperties: {
-            type: 'object',
-            properties: {
-                description: {
-                    type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.description', 'The description of the themable icon'),
-                },
-                default: {
-                    anyOf: [
-                        iconReferenceSchema,
-                        {
-                            type: 'object',
-                            properties: {
-                                fontPath: {
-                                    description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.default.fontPath', 'The path of the icon font that defines the icon.'),
-                                    type: 'string'
-                                },
-                                fontCharacter: {
-                                    description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.default.fontCharacter', 'The character for the icon in the icon font.'),
-                                    type: 'string'
-                                }
-                            },
-                            required: ['fontPath', 'fontCharacter'],
-                            defaultSnippets: [{ body: { fontPath: '${1:myiconfont.woff}', fontCharacter: '${2:\\\\E001}' } }]
-                        }
-                    ],
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/iconExtensionPoint', 'contributes.icon.default', 'The default of the icon. Either a reference to an extisting ThemeIcon or an icon in an icon font.'),
-                }
-            },
-            required: ['description', 'default'],
-            defaultSnippets: [{ body: { description: '${1:my icon}', default: { fontPath: '${2:myiconfont.woff}', fontCharacter: '${3:\\\\E001}' } } }]
-        },
-        defaultSnippets: [{ body: { '${1:my-icon-id}': { description: '${2:my icon}', default: { fontPath: '${3:myiconfont.woff}', fontCharacter: '${4:\\\\E001}' } } } }]
-    }
-}));
+iconRegistry.getIconReferenceSchema();

package/vscode/src/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.js

@@ -1,30 +1,54 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
-import { typeAndModifierIdPattern, getTokenClassificationRegistry } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
+import { getTokenClassificationRegistry, typeAndModifierIdPattern } from '../../../../platform/theme/common/tokenClassificationRegistry.js';
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenTypeExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenTypes',
     jsonSchema: {
-        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes', 'Contributes semantic token types.'),
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenTypes',
+            'Contributes semantic token types.'
+        )),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.id', 'The identifier of the semantic token type'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.id',
+                        'The identifier of the semantic token type'
+                    )),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.id.format', 'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'),
+                    patternErrorMessage: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.id.format',
+                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
+                    )),
                 },
                 superType: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.superType', 'The super type of the semantic token type'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.superType',
+                        'The super type of the semantic token type'
+                    )),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenTypes.superType.format', 'Super types should be in the form letterOrDigit[_-letterOrDigit]*'),
+                    patternErrorMessage: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenTypes.superType.format',
+                        'Super types should be in the form letterOrDigit[_-letterOrDigit]*'
+                    )),
                 },
                 description: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.color.description', 'The description of the semantic token type'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.color.description',
+                        'The description of the semantic token type'
+                    )),
                 }
             }
         }
@@ -33,19 +57,35 @@ const tokenTypeExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 const tokenModifierExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenModifiers',
     jsonSchema: {
-        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers', 'Contributes semantic token modifiers.'),
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenModifiers',
+            'Contributes semantic token modifiers.'
+        )),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 id: {
                     type: 'string',
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.id', 'The identifier of the semantic token modifier'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.id',
+                        'The identifier of the semantic token modifier'
+                    )),
                     pattern: typeAndModifierIdPattern,
-                    patternErrorMessage: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.id.format', 'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*')
+                    patternErrorMessage: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.id.format',
+                        'Identifiers should be in the form letterOrDigit[_-letterOrDigit]*'
+                    ))
                 },
                 description: {
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenModifiers.description', 'The description of the semantic token modifier')
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenModifiers.description',
+                        'The description of the semantic token modifier'
+                    ))
                 }
             }
         }
@@ -54,17 +94,29 @@ const tokenModifierExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 const tokenStyleDefaultsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenScopes',
     jsonSchema: {
-        description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes', 'Contributes semantic token scope maps.'),
+        description: ( nls.localizeWithPath(
+            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+            'contributes.semanticTokenScopes',
+            'Contributes semantic token scope maps.'
+        )),
         type: 'array',
         items: {
             type: 'object',
             properties: {
                 language: {
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes.languages', 'Lists the languge for which the defaults are.'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenScopes.languages',
+                        'Lists the languge for which the defaults are.'
+                    )),
                     type: 'string'
                 },
                 scopes: {
-                    description: nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'contributes.semanticTokenScopes.scopes', 'Maps a semantic token (described by semantic token selector) to one or more textMate scopes used to represent that token.'),
+                    description: ( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'contributes.semanticTokenScopes.scopes',
+                        'Maps a semantic token (described by semantic token selector) to one or more textMate scopes used to represent that token.'
+                    )),
                     type: 'object',
                     additionalProperties: {
                         type: 'array',
@@ -81,20 +133,40 @@ class TokenClassificationExtensionPoints {
     constructor() {
         function validateTypeOrModifier(contribution, extensionPoint, collector) {
             if (typeof contribution.id !== 'string' || contribution.id.length === 0) {
-                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.id', "'configuration.{0}.id' must be defined and can not be empty", extensionPoint));
+                collector.error(( nls.localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.id',
+                    "'configuration.{0}.id' must be defined and can not be empty",
+                    extensionPoint
+                )));
                 return false;
             }
             if (!contribution.id.match(typeAndModifierIdPattern)) {
-                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.id.format', "'configuration.{0}.id' must follow the pattern letterOrDigit[-_letterOrDigit]*", extensionPoint));
+                collector.error(( nls.localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.id.format',
+                    "'configuration.{0}.id' must follow the pattern letterOrDigit[-_letterOrDigit]*",
+                    extensionPoint
+                )));
                 return false;
             }
             const superType = contribution.superType;
             if (superType && !superType.match(typeAndModifierIdPattern)) {
-                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.superType.format', "'configuration.{0}.superType' must follow the pattern letterOrDigit[-_letterOrDigit]*", extensionPoint));
+                collector.error(( nls.localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.superType.format',
+                    "'configuration.{0}.superType' must follow the pattern letterOrDigit[-_letterOrDigit]*",
+                    extensionPoint
+                )));
                 return false;
             }
             if (typeof contribution.description !== 'string' || contribution.id.length === 0) {
-                collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.description', "'configuration.{0}.description' must be defined and can not be empty", extensionPoint));
+                collector.error(( nls.localizeWithPath(
+                    'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                    'invalid.description',
+                    "'configuration.{0}.description' must be defined and can not be empty",
+                    extensionPoint
+                )));
                 return false;
             }
             return true;
@@ -104,7 +176,11 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenTypeConfiguration', "'configuration.semanticTokenType' must be an array"));
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenTypeConfiguration',
+                        "'configuration.semanticTokenType' must be an array"
+                    )));
                     return;
                 }
                 for (const contribution of extensionValue) {
@@ -125,7 +201,11 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenModifierConfiguration', "'configuration.semanticTokenModifier' must be an array"));
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenModifierConfiguration',
+                        "'configuration.semanticTokenModifier' must be an array"
+                    )));
                     return;
                 }
                 for (const contribution of extensionValue) {
@@ -146,22 +226,38 @@ class TokenClassificationExtensionPoints {
                 const extensionValue = extension.value;
                 const collector = extension.collector;
                 if (!extensionValue || !Array.isArray(extensionValue)) {
-                    collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.configuration', "'configuration.semanticTokenScopes' must be an array"));
+                    collector.error(( nls.localizeWithPath(
+                        'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                        'invalid.semanticTokenScopes.configuration',
+                        "'configuration.semanticTokenScopes' must be an array"
+                    )));
                     return;
                 }
                 for (const contribution of extensionValue) {
                     if (contribution.language && typeof contribution.language !== 'string') {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.language', "'configuration.semanticTokenScopes.language' must be a string"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                            'invalid.semanticTokenScopes.language',
+                            "'configuration.semanticTokenScopes.language' must be a string"
+                        )));
                         continue;
                     }
                     if (!contribution.scopes || typeof contribution.scopes !== 'object') {
-                        collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes', "'configuration.semanticTokenScopes.scopes' must be defined as an object"));
+                        collector.error(( nls.localizeWithPath(
+                            'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                            'invalid.semanticTokenScopes.scopes',
+                            "'configuration.semanticTokenScopes.scopes' must be defined as an object"
+                        )));
                         continue;
                     }
                     for (const selectorString in contribution.scopes) {
                         const tmScopes = contribution.scopes[selectorString];
                         if (!Array.isArray(tmScopes) || ( tmScopes.some(l => typeof l !== 'string'))) {
-                            collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes.value', "'configuration.semanticTokenScopes.scopes' values must be an array of strings"));
+                            collector.error(( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                                'invalid.semanticTokenScopes.scopes.value',
+                                "'configuration.semanticTokenScopes.scopes' values must be an array of strings"
+                            )));
                             continue;
                         }
                         try {
@@ -169,7 +265,12 @@ class TokenClassificationExtensionPoints {
                             tokenClassificationRegistry.registerTokenStyleDefault(selector, { scopesToProbe: ( tmScopes.map(s => s.split(' '))) });
                         }
                         catch (e) {
-                            collector.error(nls.localizeWithPath('vs/workbench/services/themes/common/tokenClassificationExtensionPoint', 'invalid.semanticTokenScopes.scopes.selector', "configuration.semanticTokenScopes.scopes': Problems parsing selector {0}.", selectorString));
+                            collector.error(( nls.localizeWithPath(
+                                'vs/workbench/services/themes/common/tokenClassificationExtensionPoint',
+                                'invalid.semanticTokenScopes.scopes.selector',
+                                "configuration.semanticTokenScopes.scopes': Problems parsing selector {0}.",
+                                selectorString
+                            )));
                         }
                     }
                 }

package/vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -5,9 +5,10 @@ import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconReg
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
 const IUserDataProfileImportExportService = ( createDecorator('IUserDataProfileImportExportService'));
-const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'defaultProfileIcon', 'Icon for Default Profile.'));
-({ value: localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'profiles', "Profiles"), original: 'Profiles' });
-const PROFILE_EXTENSION = 'code-profile';
-[{ name: localizeWithPath('vs/workbench/services/userDataProfile/common/userDataProfile', 'profile', "Profile"), extensions: [PROFILE_EXTENSION] }];
+const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localizeWithPath(
+    'vs/workbench/services/userDataProfile/common/userDataProfile',
+    'defaultProfileIcon',
+    'Icon for Default Profile.'
+)));
 const CURRENT_PROFILE_CONTEXT = ( new RawContextKey('currentProfile', ''));
-export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, PROFILE_EXTENSION, defaultUserDataProfileIcon };
+export { CURRENT_PROFILE_CONTEXT, IUserDataProfileImportExportService, IUserDataProfileService, defaultUserDataProfileIcon };

package/vscode/src/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -1,19 +1,11 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
 const IUserDataSyncWorkbenchService = ( createDecorator('IUserDataSyncWorkbenchService'));
-localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'sync category', "Settings Sync");
-registerIcon('settings-sync-view-icon', Codicon.sync, localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'syncViewIcon', 'View icon of the Settings Sync view.'));
-const CONTEXT_SYNC_STATE = ( new RawContextKey('syncStatus', "uninitialized" ));
-const CONTEXT_ACCOUNT_STATE = ( new RawContextKey('userDataSyncAccountStatus', "unavailable" ));
-({
-    id: 'workbench.userDataSync.actions.downloadSyncActivity',
-    title: { original: 'Download Settings Sync Activity', value: localizeWithPath('vs/workbench/services/userDataSync/common/userDataSync', 'download sync activity title', "Download Settings Sync Activity") },
-    category: Categories.Developer,
-    f1: true,
-    precondition: ( ContextKeyExpr.and(( CONTEXT_ACCOUNT_STATE.isEqualTo("available" )), ( CONTEXT_SYNC_STATE.notEqualsTo("uninitialized" ))))
-});
-export { CONTEXT_ACCOUNT_STATE, CONTEXT_SYNC_STATE, IUserDataSyncWorkbenchService };
+registerIcon('settings-sync-view-icon', Codicon.sync, ( localizeWithPath(
+    'vs/workbench/services/userDataSync/common/userDataSync',
+    'syncViewIcon',
+    'View icon of the Settings Sync view.'
+)));
+export { IUserDataSyncWorkbenchService };

package/vscode/src/vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant.js

@@ -21,7 +21,12 @@ let StoredFileWorkingCopySaveParticipant = class StoredFileWorkingCopySavePartic
     participate(workingCopy, context, token) {
         const cts = ( new CancellationTokenSource(token));
         return this.progressService.withProgress({
-            title: localizeWithPath('vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant', 'saveParticipants', "Saving '{0}'", workingCopy.name),
+            title: ( localizeWithPath(
+                'vs/workbench/services/workingCopy/common/storedFileWorkingCopySaveParticipant',
+                'saveParticipants',
+                "Saving '{0}'",
+                workingCopy.name
+            )),
             location: 15 ,
             cancellable: true,
             delay: workingCopy.isDirty() ? 3000 : 5000