@codingame/monaco-vscode-api 1.69.8 → 1.69.9

package/dist/theme.js

@@ -1,27 +1,27 @@
-import { p as parse$1, w as getNodeType, E as Emitter } from './polyfill.js';
-import { E as ExtensionsRegistry, S as Sequencer, I as IExtensionService, o as IBrowserWorkbenchEnvironmentService, p as IHostColorSchemeService, q as IUserDataInitializationService, m as ExtensionMessageCollector } from './missing-services.js';
-import { b as __decorate, d as __param } from './contextkey.js';
-import { T as THEME_SCOPE_OPEN_PAREN, a as THEME_SCOPE_CLOSE_PAREN, b as THEME_SCOPE_WILDCARD, t as themeScopeRegex, E as ExtensionData, V as VS_HC_LIGHT_THEME, c as VS_HC_THEME, d as VS_LIGHT_THEME, e as VS_DARK_THEME, f as ThemeSettings } from './workbenchThemeService.js';
-import { Extensions, editorBackground, editorForeground, editorSelectionBackground, editorInactiveSelection, editorSelectionHighlight, editorFindMatchHighlight, editorFindMatch, editorHoverHighlight, editorFindRangeHighlight, workbenchColorsSchemaId, asCssVariableName } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { E as Emitter, k as parse$1, m as getNodeType } from './polyfill.js';
+import { E as ExtensionsRegistry, j as ExtensionMessageCollector, S as Sequencer, I as IExtensionService, o as IBrowserWorkbenchEnvironmentService, p as IHostColorSchemeService, q as IUserDataInitializationService } from './missing-services.js';
+import { _ as __decorate, a as __param } from './contextkey.js';
+import { T as ThemeSettings, E as ExtensionData, V as VS_DARK_THEME, a as VS_LIGHT_THEME, b as VS_HC_THEME, c as VS_HC_LIGHT_THEME, d as THEME_SCOPE_OPEN_PAREN, e as THEME_SCOPE_CLOSE_PAREN, f as THEME_SCOPE_WILDCARD, t as themeScopeRegex } from './workbenchThemeService.js';
+import { editorBackground, editorForeground, editorSelectionBackground, editorInactiveSelection, editorSelectionHighlight, editorFindMatchHighlight, editorFindMatch, editorHoverHighlight, editorFindRangeHighlight, workbenchColorsSchemaId, asCssVariableName, Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
 import { editorLineHighlight, editorRangeHighlight, editorCursorForeground, editorWhitespaces, editorIndentGuides, editorActiveIndentGuides } from 'monaco-editor/esm/vs/editor/common/core/editorColorRegistry.js';
 import { g as getParseErrorMessage } from './jsonErrorMessages.js';
-import { g as getTokenClassificationRegistry, T as TokenStyle, p as parseClassifierString, S as SemanticTokenRule, t as tokenStylingSchemaId } from './tokenClassificationRegistry.js';
-import { isUndefined, isObject, isArray, isString, isBoolean } from 'monaco-editor/esm/vs/base/common/types.js';
+import { t as tokenStylingSchemaId, T as TokenStyle, p as parseClassifierString, S as SemanticTokenRule, g as getTokenClassificationRegistry } from './tokenClassificationRegistry.js';
+import { isUndefined, isString, isObject, isArray, isBoolean } from 'monaco-editor/esm/vs/base/common/types.js';
 import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
-import { getThemeTypeSelector, ThemeIcon, Extensions as Extensions$3, IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IThemeService, getThemeTypeSelector, ThemeIcon, Extensions as Extensions$3 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import { extname, joinPath, dirname, isEqualOrParent, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { joinPath, isEqual, extname, dirname, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { iconsSchemaId, IconFontDefinition, getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { getIconRegistry, iconsSchemaId, IconFontDefinition } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import { asCSSUrl, createStyleSheet } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { a as getRemoteAuthority, I as IExtensionResourceLoaderService, g as getServiceOverride$1, r as registerExtensionFile } from './files.js';
+import { createStyleSheet, asCSSUrl } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { r as registerExtensionFile, g as getServiceOverride$1, a as getRemoteAuthority, I as IExtensionResourceLoaderService } from './files.js';
 import { I as IWorkbenchLayoutService } from './layoutService.js';
-import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { d as IFileService, S as Services } from './services2.js';
+import { S as Services, i as IFileService } from './services2.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { getIconsStyleSheet } from 'monaco-editor/esm/vs/platform/theme/browser/iconsStyleSheet.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -32,12 +32,12 @@ import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/l
 import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { c as consoleExtensionMessageHandler } from './tools.js';
-import { D as DEFAULT_EXTENSION } from './extHost.js';
+import { bd as DEFAULT_EXTENSION } from './extHost.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 function getColorRegistry () {
-  return Registry.as(Extensions.ColorContribution)
+  return ( Registry.as(Extensions$2.ColorContribution));
 }
 const settingToColorIdMapping = {};
 function addSettingMapping(settingId, colorId) {
@@ -62,7 +62,7 @@ function convertSettings(oldSettings, result) {
                     if (mappings) {
                         const colorHex = settings[key];
                         if (typeof colorHex === 'string') {
-                            const color = ( Color.fromHex(colorHex));
+                            const color = ( (Color.fromHex(colorHex)));
                             for (const colorId of mappings) {
                                 result.colors[colorId] = color;
                             }
@@ -518,7 +518,7 @@ function _parse(content, filename, locationKeyName) {
                 acceptInteger(parseInt(parseTagValue(tag), 10));
                 continue;
             case 'date':
-                acceptDate(( new Date(parseTagValue(tag))));
+                acceptDate(( (new Date(parseTagValue(tag)))));
                 continue;
             case 'data':
                 acceptData(parseTagValue(tag));
@@ -658,7 +658,7 @@ function newTokenizer(input) {
         }
     };
 }
-const colorRegistry = ( Registry.as(Extensions.ColorContribution));
+const colorRegistry = ( (Registry.as(Extensions$2.ColorContribution)));
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenGroupToScopesMap = {
     comments: ['comment', 'punctuation.definition.comment'],
@@ -822,7 +822,7 @@ class ColorThemeData {
     }
     getTokenColorIndex() {
         if (!this.tokenColorIndex) {
-            const index = ( new TokenColorIndex());
+            const index = ( (new TokenColorIndex()));
             this.tokenColors.forEach(rule => {
                 index.add(rule.settings.foreground);
                 index.add(rule.settings.background);
@@ -937,7 +937,7 @@ class ColorThemeData {
         for (const id in colors) {
             const colorVal = colors[id];
             if (typeof colorVal === 'string') {
-                this.customColorMap[id] = ( Color.fromHex(colorVal));
+                this.customColorMap[id] = ( (Color.fromHex(colorVal)));
             }
         }
     }
@@ -1122,19 +1122,19 @@ class ColorThemeData {
         return ColorThemeData.createUnloadedTheme(getThemeTypeSelector(themeType), colorMap);
     }
     static createUnloadedTheme(id, colorMap) {
-        const themeData = ( new ColorThemeData(id, '', '__' + id));
+        const themeData = ( (new ColorThemeData(id, '', '__' + id)));
         themeData.isLoaded = false;
         themeData.themeTokenColors = [];
         themeData.watch = false;
         if (colorMap) {
             for (const id in colorMap) {
-                themeData.colorMap[id] = ( Color.fromHex(colorMap[id]));
+                themeData.colorMap[id] = ( (Color.fromHex(colorMap[id])));
             }
         }
         return themeData;
     }
     static createLoadedEmptyTheme(id, settingsId) {
-        const themeData = ( new ColorThemeData(id, '', settingsId));
+        const themeData = ( (new ColorThemeData(id, '', settingsId)));
         themeData.isLoaded = true;
         themeData.themeTokenColors = [];
         themeData.watch = false;
@@ -1147,13 +1147,13 @@ class ColorThemeData {
         }
         try {
             const data = JSON.parse(input);
-            const theme = ( new ColorThemeData('', '', ''));
+            const theme = ( (new ColorThemeData('', '', '')));
             for (const key in data) {
                 switch (key) {
                     case 'colorMap': {
                         const colorMapData = data[key];
                         for (const id in colorMapData) {
-                            theme.colorMap[id] = ( Color.fromHex(colorMapData[id]));
+                            theme.colorMap[id] = ( (Color.fromHex(colorMapData[id])));
                         }
                         break;
                     }
@@ -1199,7 +1199,7 @@ class ColorThemeData {
         const id = `${baseTheme} ${themeSelector}`;
         const label = theme.label || basename(theme.path);
         const settingsId = theme.id || label;
-        const themeData = ( new ColorThemeData(id, label, settingsId));
+        const themeData = ( (new ColorThemeData(id, label, settingsId)));
         themeData.description = theme.description;
         themeData.watch = theme._watch === true;
         themeData.location = colorThemeLocation;
@@ -1226,17 +1226,17 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
         const errors = [];
         const contentValue = parse$1(content, errors);
         if (errors.length > 0) {
-            return Promise.reject(( new Error(( localize(
+            return Promise.reject(( (new Error( (localize(
                 'error.cannotparsejson',
                 "Problems parsing JSON theme file: {0}",
                 errors.map(e => getParseErrorMessage(e.error)).join(', ')
-            )))));
+            ))))));
         }
         else if (getNodeType(contentValue) !== 'object') {
-            return Promise.reject(( new Error(( localize(
+            return Promise.reject(( (new Error( (localize(
                 'error.invalidformat',
                 "Invalid format for JSON theme file: Object expected."
-            )))));
+            ))))));
         }
         if (contentValue.include) {
             await _loadColorTheme(extensionResourceLoaderService, joinPath(dirname(themeLocation), contentValue.include), result);
@@ -1249,16 +1249,16 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
         const colors = contentValue.colors;
         if (colors) {
             if (typeof colors !== 'object') {
-                return Promise.reject(( new Error(( localize(
+                return Promise.reject(( (new Error( (localize(
                     { key: 'error.invalidformat.colors', comment: ['{0} will be replaced by a path. Values in quotes should not be translated.'] },
                     "Problem parsing color theme file: {0}. Property 'colors' is not of type 'object'.",
-                    ( themeLocation.toString())
-                )))));
+                     (themeLocation.toString())
+                ))))));
             }
             for (const colorId in colors) {
                 const colorHex = colors[colorId];
                 if (typeof colorHex === 'string') {
-                    result.colors[colorId] = ( Color.fromHex(colors[colorId]));
+                    result.colors[colorId] = ( (Color.fromHex(colors[colorId])));
                 }
             }
         }
@@ -1271,11 +1271,11 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
                 await _loadSyntaxTokens(extensionResourceLoaderService, joinPath(dirname(themeLocation), tokenColors), result);
             }
             else {
-                return Promise.reject(( new Error(( localize(
+                return Promise.reject(( (new Error( (localize(
                     { key: 'error.invalidformat.tokenColors', comment: ['{0} will be replaced by a path. Values in quotes should not be translated.'] },
                     "Problem parsing color theme file: {0}. Property 'tokenColors' should be either an array specifying colors or a path to a TextMate theme file",
-                    ( themeLocation.toString())
-                )))));
+                     (themeLocation.toString())
+                ))))));
             }
         }
         const semanticTokenColors = contentValue.semanticTokenColors;
@@ -1288,11 +1288,11 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
                     }
                 }
                 catch (e) {
-                    return Promise.reject(( new Error(( localize(
+                    return Promise.reject(( (new Error( (localize(
                         { key: 'error.invalidformat.semanticTokenColors', comment: ['{0} will be replaced by a path. Values in quotes should not be translated.'] },
                         "Problem parsing color theme file: {0}. Property 'semanticTokenColors' contains a invalid selector",
-                        ( themeLocation.toString())
-                    )))));
+                         (themeLocation.toString())
+                    ))))));
                 }
             }
         }
@@ -1307,24 +1307,26 @@ function _loadSyntaxTokens(extensionResourceLoaderService, themeLocation, result
             const contentValue = parse(content);
             const settings = contentValue.settings;
             if (!Array.isArray(settings)) {
-                return Promise.reject(( new Error(( localize(
+                return Promise.reject(( (new Error( (localize(
                     'error.plist.invalidformat',
                     "Problem parsing tmTheme file: {0}. 'settings' is not array."
-                )))));
+                ))))));
             }
             convertSettings(settings, result);
             return Promise.resolve(null);
         }
         catch (e) {
-            return Promise.reject(( new Error(( localize('error.cannotparse', "Problems parsing tmTheme file: {0}", e.message)))));
+            return Promise.reject(( (new Error(
+                 (localize('error.cannotparse', "Problems parsing tmTheme file: {0}", e.message))
+            ))));
         }
     }, error => {
-        return Promise.reject(( new Error(( localize(
+        return Promise.reject(( (new Error( (localize(
             'error.cannotload',
             "Problems loading tmTheme file {0}: {1}",
-            ( themeLocation.toString()),
+             (themeLocation.toString()),
             error.message
-        )))));
+        ))))));
     });
 }
 const defaultThemeColors = {
@@ -1523,29 +1525,29 @@ const schema$1 = {
                 properties: {
                     id: {
                         type: 'string',
-                        description: ( localize('schema.id', 'The ID of the font.')),
+                        description: ( (localize('schema.id', 'The ID of the font.'))),
                         pattern: fontIdRegex,
-                        patternErrorMessage: ( localize(
+                        patternErrorMessage: ( (localize(
                             'schema.id.formatError',
                             'The ID must only contain letters, numbers, underscore and minus.'
-                        ))
+                        )))
                     },
                     src: {
                         type: 'array',
-                        description: ( localize('schema.src', 'The location of the font.')),
+                        description: ( (localize('schema.src', 'The location of the font.'))),
                         items: {
                             type: 'object',
                             properties: {
                                 path: {
                                     type: 'string',
-                                    description: ( localize(
+                                    description: ( (localize(
                                         'schema.font-path',
                                         'The font path, relative to the current product icon theme file.'
-                                    )),
+                                    ))),
                                 },
                                 format: {
                                     type: 'string',
-                                    description: ( localize('schema.font-format', 'The format of the font.')),
+                                    description: ( (localize('schema.font-format', 'The format of the font.'))),
                                     enum: ['woff', 'woff2', 'truetype', 'opentype', 'embedded-opentype', 'svg']
                                 }
                             },
@@ -1557,10 +1559,10 @@ const schema$1 = {
                     },
                     weight: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.font-weight',
                             'The weight of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight for valid values.'
-                        )),
+                        ))),
                         anyOf: [
                             { enum: ['normal', 'bold', 'lighter', 'bolder'] },
                             { type: 'string', pattern: fontWeightRegex }
@@ -1568,10 +1570,10 @@ const schema$1 = {
                     },
                     style: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.font-style',
                             'The style of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-style for valid values.'
-                        )),
+                        ))),
                         anyOf: [
                             { enum: ['normal', 'italic', 'oblique'] },
                             { type: 'string', pattern: fontStyleRegex }
@@ -1585,13 +1587,13 @@ const schema$1 = {
             }
         },
         iconDefinitions: {
-            description: ( localize('schema.iconDefinitions', 'Association of icon name to a font character.')),
+            description: ( (localize('schema.iconDefinitions', 'Association of icon name to a font character.'))),
             $ref: iconsSchemaId
         }
     }
 };
 function registerProductIconThemeSchemas() {
-    const schemaRegistry = ( Registry.as(Extensions$1.JSONContribution));
+    const schemaRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
     schemaRegistry.registerSchema(schemaId$1, schema$1);
 }
 const schemaId = 'vscode://schemas/icon-theme';
@@ -1602,84 +1604,84 @@ const schema = {
     definitions: {
         folderExpanded: {
             type: 'string',
-            description: ( localize(
+            description: ( (localize(
                 'schema.folderExpanded',
                 'The folder icon for expanded folders. The expanded folder icon is optional. If not set, the icon defined for folder will be shown.'
-            ))
+            )))
         },
         folder: {
             type: 'string',
-            description: ( localize(
+            description: ( (localize(
                 'schema.folder',
                 'The folder icon for collapsed folders, and if folderExpanded is not set, also for expanded folders.'
-            ))
+            )))
         },
         file: {
             type: 'string',
-            description: ( localize(
+            description: ( (localize(
                 'schema.file',
                 'The default file icon, shown for all files that don\'t match any extension, filename or language id.'
-            ))
+            )))
         },
         folderNames: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.folderNames',
                 'Associates folder names to icons. The object key is the folder name, not including any path segments. No patterns or wildcards are allowed. Folder name matching is case insensitive.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'string',
-                description: ( localize('schema.folderName', 'The ID of the icon definition for the association.'))
+                description: ( (localize('schema.folderName', 'The ID of the icon definition for the association.')))
             }
         },
         folderNamesExpanded: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.folderNamesExpanded',
                 'Associates folder names to icons for expanded folders. The object key is the folder name, not including any path segments. No patterns or wildcards are allowed. Folder name matching is case insensitive.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'string',
-                description: ( localize(
+                description: ( (localize(
                     'schema.folderNameExpanded',
                     'The ID of the icon definition for the association.'
-                ))
+                )))
             }
         },
         fileExtensions: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.fileExtensions',
                 'Associates file extensions to icons. The object key is the file extension name. The extension name is the last segment of a file name after the last dot (not including the dot). Extensions are compared case insensitive.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'string',
-                description: ( localize(
+                description: ( (localize(
                     'schema.fileExtension',
                     'The ID of the icon definition for the association.'
-                ))
+                )))
             }
         },
         fileNames: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.fileNames',
                 'Associates file names to icons. The object key is the full file name, but not including any path segments. File name can include dots and a possible file extension. No patterns or wildcards are allowed. File name matching is case insensitive.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'string',
-                description: ( localize('schema.fileName', 'The ID of the icon definition for the association.'))
+                description: ( (localize('schema.fileName', 'The ID of the icon definition for the association.')))
             }
         },
         languageIds: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.languageIds',
                 'Associates languages to icons. The object key is the language id as defined in the language contribution point.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'string',
-                description: ( localize('schema.languageId', 'The ID of the icon definition for the association.'))
+                description: ( (localize('schema.languageId', 'The ID of the icon definition for the association.')))
             }
         },
         associations: {
@@ -1715,35 +1717,35 @@ const schema = {
     properties: {
         fonts: {
             type: 'array',
-            description: ( localize('schema.fonts', 'Fonts that are used in the icon definitions.')),
+            description: ( (localize('schema.fonts', 'Fonts that are used in the icon definitions.'))),
             items: {
                 type: 'object',
                 properties: {
                     id: {
                         type: 'string',
-                        description: ( localize('schema.id', 'The ID of the font.')),
+                        description: ( (localize('schema.id', 'The ID of the font.'))),
                         pattern: fontIdRegex,
-                        patternErrorMessage: ( localize(
+                        patternErrorMessage: ( (localize(
                             'schema.id.formatError',
                             'The ID must only contain letter, numbers, underscore and minus.'
-                        ))
+                        )))
                     },
                     src: {
                         type: 'array',
-                        description: ( localize('schema.src', 'The location of the font.')),
+                        description: ( (localize('schema.src', 'The location of the font.'))),
                         items: {
                             type: 'object',
                             properties: {
                                 path: {
                                     type: 'string',
-                                    description: ( localize(
+                                    description: ( (localize(
                                         'schema.font-path',
                                         'The font path, relative to the current file icon theme file.'
-                                    )),
+                                    ))),
                                 },
                                 format: {
                                     type: 'string',
-                                    description: ( localize('schema.font-format', 'The format of the font.')),
+                                    description: ( (localize('schema.font-format', 'The format of the font.'))),
                                     enum: ['woff', 'woff2', 'truetype', 'opentype', 'embedded-opentype', 'svg']
                                 }
                             },
@@ -1755,26 +1757,26 @@ const schema = {
                     },
                     weight: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.font-weight',
                             'The weight of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight for valid values.'
-                        )),
+                        ))),
                         pattern: fontWeightRegex
                     },
                     style: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.font-style',
                             'The style of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-style for valid values.'
-                        )),
+                        ))),
                         pattern: fontStyleRegex
                     },
                     size: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.font-size',
                             'The default size of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-size for valid values.'
-                        )),
+                        ))),
                         pattern: fontSizeRegex
                     }
                 },
@@ -1786,50 +1788,50 @@ const schema = {
         },
         iconDefinitions: {
             type: 'object',
-            description: ( localize(
+            description: ( (localize(
                 'schema.iconDefinitions',
                 'Description of all icons that can be used when associating files to icons.'
-            )),
+            ))),
             additionalProperties: {
                 type: 'object',
-                description: ( localize(
+                description: ( (localize(
                     'schema.iconDefinition',
                     'An icon definition. The object key is the ID of the definition.'
-                )),
+                ))),
                 properties: {
                     iconPath: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.iconPath',
                             'When using a SVG or PNG: The path to the image. The path is relative to the icon set file.'
-                        ))
+                        )))
                     },
                     fontCharacter: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.fontCharacter',
                             'When using a glyph font: The character in the font to use.'
-                        ))
+                        )))
                     },
                     fontColor: {
                         type: 'string',
                         format: 'color-hex',
-                        description: ( localize('schema.fontColor', 'When using a glyph font: The color to use.'))
+                        description: ( (localize('schema.fontColor', 'When using a glyph font: The color to use.')))
                     },
                     fontSize: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.fontSize',
                             'When using a font: The font size in percentage to the text font. If not set, defaults to the size in the font definition.'
-                        )),
+                        ))),
                         pattern: fontSizeRegex
                     },
                     fontId: {
                         type: 'string',
-                        description: ( localize(
+                        description: ( (localize(
                             'schema.fontId',
                             'When using a font: The id of the font. If not set, defaults to the first font definition.'
-                        ))
+                        )))
                     }
                 }
             }
@@ -1860,36 +1862,36 @@ const schema = {
         },
         light: {
             $ref: '#/definitions/associations',
-            description: ( localize(
+            description: ( (localize(
                 'schema.light',
                 'Optional associations for file icons in light color themes.'
-            ))
+            )))
         },
         highContrast: {
             $ref: '#/definitions/associations',
-            description: ( localize(
+            description: ( (localize(
                 'schema.highContrast',
                 'Optional associations for file icons in high contrast color themes.'
-            ))
+            )))
         },
         hidesExplorerArrows: {
             type: 'boolean',
-            description: ( localize(
+            description: ( (localize(
                 'schema.hidesExplorerArrows',
                 'Configures whether the file explorer\'s arrows should be hidden when this theme is active.'
-            ))
+            )))
         },
         showLanguageModeIcons: {
             type: 'boolean',
-            description: ( localize(
+            description: ( (localize(
                 'schema.showLanguageModeIcons',
                 'Configures whether the default language icons should be used if the theme does not define an icon for a language.'
-            ))
+            )))
         }
     }
 };
 function registerFileIconThemeSchemas() {
-    const schemaRegistry = ( Registry.as(Extensions$1.JSONContribution));
+    const schemaRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
     schemaRegistry.registerSchema(schemaId, schema);
 }
 class FileIconThemeData {
@@ -1915,7 +1917,7 @@ class FileIconThemeData {
         const id = extensionData.extensionId + '-' + iconTheme.id;
         const label = iconTheme.label || basename(iconTheme.path);
         const settingsId = iconTheme.id;
-        const themeData = ( new FileIconThemeData(id, label, settingsId));
+        const themeData = ( (new FileIconThemeData(id, label, settingsId)));
         themeData.description = iconTheme.description;
         themeData.location = iconThemeLocation;
         themeData.extensionData = extensionData;
@@ -1926,7 +1928,7 @@ class FileIconThemeData {
     static get noIconTheme() {
         let themeData = FileIconThemeData._noIconTheme;
         if (!themeData) {
-            themeData = FileIconThemeData._noIconTheme = ( new FileIconThemeData('', '', null));
+            themeData = FileIconThemeData._noIconTheme = ( (new FileIconThemeData('', '', null)));
             themeData.hasFileIcons = false;
             themeData.hasFolderIcons = false;
             themeData.hidesExplorerArrows = false;
@@ -1937,7 +1939,7 @@ class FileIconThemeData {
         return themeData;
     }
     static createUnloadedTheme(id) {
-        const themeData = ( new FileIconThemeData(id, '', '__' + id));
+        const themeData = ( (new FileIconThemeData(id, '', '__' + id)));
         themeData.isLoaded = false;
         themeData.hasFileIcons = false;
         themeData.hasFolderIcons = false;
@@ -1953,7 +1955,7 @@ class FileIconThemeData {
         }
         try {
             const data = JSON.parse(input);
-            const theme = ( new FileIconThemeData('', '', null));
+            const theme = ( (new FileIconThemeData('', '', null)));
             for (const key in data) {
                 switch (key) {
                     case 'id':
@@ -2022,17 +2024,17 @@ class FileIconThemeLoader {
             const errors = [];
             const contentValue = parse$1(content, errors);
             if (errors.length > 0) {
-                return Promise.reject(( new Error(( localize(
+                return Promise.reject(( (new Error( (localize(
                     'error.cannotparseicontheme',
                     "Problems parsing file icons file: {0}",
                     errors.map(e => getParseErrorMessage(e.error)).join(', ')
-                )))));
+                ))))));
             }
             else if (getNodeType(contentValue) !== 'object') {
-                return Promise.reject(( new Error(( localize(
+                return Promise.reject(( (new Error( (localize(
                     'error.invalidformat',
                     "Invalid format for file icons theme file: Object expected."
-                )))));
+                ))))));
             }
             return Promise.resolve(contentValue);
         });
@@ -2167,7 +2169,7 @@ class FileIconThemeLoader {
         const showLanguageModeIcons = iconThemeDocument.showLanguageModeIcons === true || (hasSpecificFileIcons && iconThemeDocument.showLanguageModeIcons !== false);
         const cssRules = [];
         const fonts = iconThemeDocument.fonts;
-        const fontSizes = ( new Map());
+        const fontSizes = ( (new Map()));
         if (Array.isArray(fonts)) {
             const defaultFontSize = fonts[0].size || '150%';
             fonts.forEach(font => {
@@ -2358,34 +2360,34 @@ const textmateColorSchema = {
         },
         settings: {
             type: 'object',
-            description: ( localize('schema.token.settings', 'Colors and styles for the token.')),
+            description: ( (localize('schema.token.settings', 'Colors and styles for the token.'))),
             properties: {
                 foreground: {
                     type: 'string',
-                    description: ( localize('schema.token.foreground', 'Foreground color for the token.')),
+                    description: ( (localize('schema.token.foreground', 'Foreground color for the token.'))),
                     format: 'color-hex',
                     default: '#ff0000'
                 },
                 background: {
                     type: 'string',
-                    deprecationMessage: ( localize(
+                    deprecationMessage: ( (localize(
                         'schema.token.background.warning',
                         'Token background colors are currently not supported.'
-                    ))
+                    )))
                 },
                 fontStyle: {
                     type: 'string',
-                    description: ( localize(
+                    description: ( (localize(
                         'schema.token.fontStyle',
                         'Font style of the rule: \'italic\', \'bold\', \'underline\', \'strikethrough\' or a combination. The empty string unsets inherited settings.'
-                    )),
+                    ))),
                     pattern: '^(\\s*\\b(italic|bold|underline|strikethrough))*\\s*$',
-                    patternErrorMessage: ( localize(
+                    patternErrorMessage: ( (localize(
                         'schema.fontStyle.error',
                         'Font style must be \'italic\', \'bold\', \'underline\', \'strikethrough\' or a combination or the empty string.'
-                    )),
+                    ))),
                     defaultSnippets: [
-                        { label: ( localize('schema.token.fontStyle.none', 'None (clear inherited style)')), bodyText: '""' },
+                        { label: ( (localize('schema.token.fontStyle.none', 'None (clear inherited style)'))), bodyText: '""' },
                         { body: 'italic' },
                         { body: 'bold' },
                         { body: 'underline' },
@@ -2414,13 +2416,13 @@ const textmateColorSchema = {
         properties: {
             name: {
                 type: 'string',
-                description: ( localize('schema.properties.name', 'Description of the rule.'))
+                description: ( (localize('schema.properties.name', 'Description of the rule.')))
             },
             scope: {
-                description: ( localize(
+                description: ( (localize(
                     'schema.properties.scope',
                     'Scope selector against which this rule matches.'
-                )),
+                ))),
                 anyOf: [
                     {
                         enum: textMateScopes
@@ -2459,166 +2461,172 @@ const colorThemeSchema = {
     allowTrailingCommas: true,
     properties: {
         colors: {
-            description: ( localize('schema.workbenchColors', 'Colors in the workbench')),
+            description: ( (localize('schema.workbenchColors', 'Colors in the workbench'))),
             $ref: workbenchColorsSchemaId,
             additionalProperties: false
         },
         tokenColors: {
             anyOf: [{
                     type: 'string',
-                    description: ( localize(
+                    description: ( (localize(
                         'schema.tokenColors.path',
                         'Path to a tmTheme file (relative to the current file).'
-                    ))
+                    )))
                 },
                 {
-                    description: ( localize('schema.colors', 'Colors for syntax highlighting')),
+                    description: ( (localize('schema.colors', 'Colors for syntax highlighting'))),
                     $ref: textmateColorsSchemaId
                 }
             ]
         },
         semanticHighlighting: {
             type: 'boolean',
-            description: ( localize(
+            description: ( (localize(
                 'schema.supportsSemanticHighlighting',
                 'Whether semantic highlighting should be enabled for this theme.'
-            ))
+            )))
         },
         semanticTokenColors: {
             type: 'object',
-            description: ( localize('schema.semanticTokenColors', 'Colors for semantic tokens')),
+            description: ( (localize('schema.semanticTokenColors', 'Colors for semantic tokens'))),
             $ref: tokenStylingSchemaId
         }
     }
 };
 function registerColorThemeSchemas() {
-    const schemaRegistry = ( Registry.as(Extensions$1.JSONContribution));
+    const schemaRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
     schemaRegistry.registerSchema(colorThemeSchemaId, colorThemeSchema);
     schemaRegistry.registerSchema(textmateColorsSchemaId, textmateColorSchema);
 }
 function registerColorThemeExtensionPoint() {
-    return ( ExtensionsRegistry.registerExtensionPoint({
-        extensionPoint: 'themes',
-        jsonSchema: {
-            description: ( localize(
-                'vscode.extension.contributes.themes',
-                'Contributes textmate color themes.'
-            )),
-            type: 'array',
-            items: {
-                type: 'object',
-                defaultSnippets: [{ body: { label: '${1:label}', id: '${2:id}', uiTheme: VS_DARK_THEME, path: './themes/${3:id}.tmTheme.' } }],
-                properties: {
-                    id: {
-                        description: ( localize(
-                            'vscode.extension.contributes.themes.id',
-                            'Id of the color theme as used in the user settings.'
-                        )),
-                        type: 'string'
-                    },
-                    label: {
-                        description: ( localize(
-                            'vscode.extension.contributes.themes.label',
-                            'Label of the color theme as shown in the UI.'
-                        )),
-                        type: 'string'
-                    },
-                    uiTheme: {
-                        description: ( localize(
-                            'vscode.extension.contributes.themes.uiTheme',
-                            'Base theme defining the colors around the editor: \'vs\' is the light color theme, \'vs-dark\' is the dark color theme. \'hc-black\' is the dark high contrast theme, \'hc-light\' is the light high contrast theme.'
-                        )),
-                        enum: [VS_LIGHT_THEME, VS_DARK_THEME, VS_HC_THEME, VS_HC_LIGHT_THEME]
+    return (
+         (ExtensionsRegistry.registerExtensionPoint({
+            extensionPoint: 'themes',
+            jsonSchema: {
+                description: ( (localize(
+                    'vscode.extension.contributes.themes',
+                    'Contributes textmate color themes.'
+                ))),
+                type: 'array',
+                items: {
+                    type: 'object',
+                    defaultSnippets: [{ body: { label: '${1:label}', id: '${2:id}', uiTheme: VS_DARK_THEME, path: './themes/${3:id}.tmTheme.' } }],
+                    properties: {
+                        id: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.themes.id',
+                                'Id of the color theme as used in the user settings.'
+                            ))),
+                            type: 'string'
+                        },
+                        label: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.themes.label',
+                                'Label of the color theme as shown in the UI.'
+                            ))),
+                            type: 'string'
+                        },
+                        uiTheme: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.themes.uiTheme',
+                                'Base theme defining the colors around the editor: \'vs\' is the light color theme, \'vs-dark\' is the dark color theme. \'hc-black\' is the dark high contrast theme, \'hc-light\' is the light high contrast theme.'
+                            ))),
+                            enum: [VS_LIGHT_THEME, VS_DARK_THEME, VS_HC_THEME, VS_HC_LIGHT_THEME]
+                        },
+                        path: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.themes.path',
+                                'Path of the tmTheme file. The path is relative to the extension folder and is typically \'./colorthemes/awesome-color-theme.json\'.'
+                            ))),
+                            type: 'string'
+                        }
                     },
-                    path: {
-                        description: ( localize(
-                            'vscode.extension.contributes.themes.path',
-                            'Path of the tmTheme file. The path is relative to the extension folder and is typically \'./colorthemes/awesome-color-theme.json\'.'
-                        )),
-                        type: 'string'
-                    }
-                },
-                required: ['path', 'uiTheme']
+                    required: ['path', 'uiTheme']
+                }
             }
-        }
-    }));
+        }))
+    );
 }
 function registerFileIconThemeExtensionPoint() {
-    return ( ExtensionsRegistry.registerExtensionPoint({
-        extensionPoint: 'iconThemes',
-        jsonSchema: {
-            description: ( localize('vscode.extension.contributes.iconThemes', 'Contributes file icon themes.')),
-            type: 'array',
-            items: {
-                type: 'object',
-                defaultSnippets: [{ body: { id: '${1:id}', label: '${2:label}', path: './fileicons/${3:id}-icon-theme.json' } }],
-                properties: {
-                    id: {
-                        description: ( localize(
-                            'vscode.extension.contributes.iconThemes.id',
-                            'Id of the file icon theme as used in the user settings.'
-                        )),
-                        type: 'string'
-                    },
-                    label: {
-                        description: ( localize(
-                            'vscode.extension.contributes.iconThemes.label',
-                            'Label of the file icon theme as shown in the UI.'
-                        )),
-                        type: 'string'
+    return (
+         (ExtensionsRegistry.registerExtensionPoint({
+            extensionPoint: 'iconThemes',
+            jsonSchema: {
+                description: ( (localize('vscode.extension.contributes.iconThemes', 'Contributes file icon themes.'))),
+                type: 'array',
+                items: {
+                    type: 'object',
+                    defaultSnippets: [{ body: { id: '${1:id}', label: '${2:label}', path: './fileicons/${3:id}-icon-theme.json' } }],
+                    properties: {
+                        id: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.iconThemes.id',
+                                'Id of the file icon theme as used in the user settings.'
+                            ))),
+                            type: 'string'
+                        },
+                        label: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.iconThemes.label',
+                                'Label of the file icon theme as shown in the UI.'
+                            ))),
+                            type: 'string'
+                        },
+                        path: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.iconThemes.path',
+                                'Path of the file icon theme definition file. The path is relative to the extension folder and is typically \'./fileicons/awesome-icon-theme.json\'.'
+                            ))),
+                            type: 'string'
+                        }
                     },
-                    path: {
-                        description: ( localize(
-                            'vscode.extension.contributes.iconThemes.path',
-                            'Path of the file icon theme definition file. The path is relative to the extension folder and is typically \'./fileicons/awesome-icon-theme.json\'.'
-                        )),
-                        type: 'string'
-                    }
-                },
-                required: ['path', 'id']
+                    required: ['path', 'id']
+                }
             }
-        }
-    }));
+        }))
+    );
 }
 function registerProductIconThemeExtensionPoint() {
-    return ( ExtensionsRegistry.registerExtensionPoint({
-        extensionPoint: 'productIconThemes',
-        jsonSchema: {
-            description: ( localize(
-                'vscode.extension.contributes.productIconThemes',
-                'Contributes product icon themes.'
-            )),
-            type: 'array',
-            items: {
-                type: 'object',
-                defaultSnippets: [{ body: { id: '${1:id}', label: '${2:label}', path: './producticons/${3:id}-product-icon-theme.json' } }],
-                properties: {
-                    id: {
-                        description: ( localize(
-                            'vscode.extension.contributes.productIconThemes.id',
-                            'Id of the product icon theme as used in the user settings.'
-                        )),
-                        type: 'string'
-                    },
-                    label: {
-                        description: ( localize(
-                            'vscode.extension.contributes.productIconThemes.label',
-                            'Label of the product icon theme as shown in the UI.'
-                        )),
-                        type: 'string'
+    return (
+         (ExtensionsRegistry.registerExtensionPoint({
+            extensionPoint: 'productIconThemes',
+            jsonSchema: {
+                description: ( (localize(
+                    'vscode.extension.contributes.productIconThemes',
+                    'Contributes product icon themes.'
+                ))),
+                type: 'array',
+                items: {
+                    type: 'object',
+                    defaultSnippets: [{ body: { id: '${1:id}', label: '${2:label}', path: './producticons/${3:id}-product-icon-theme.json' } }],
+                    properties: {
+                        id: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.productIconThemes.id',
+                                'Id of the product icon theme as used in the user settings.'
+                            ))),
+                            type: 'string'
+                        },
+                        label: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.productIconThemes.label',
+                                'Label of the product icon theme as shown in the UI.'
+                            ))),
+                            type: 'string'
+                        },
+                        path: {
+                            description: ( (localize(
+                                'vscode.extension.contributes.productIconThemes.path',
+                                'Path of the product icon theme definition file. The path is relative to the extension folder and is typically \'./producticons/awesome-product-icon-theme.json\'.'
+                            ))),
+                            type: 'string'
+                        }
                     },
-                    path: {
-                        description: ( localize(
-                            'vscode.extension.contributes.productIconThemes.path',
-                            'Path of the product icon theme definition file. The path is relative to the extension folder and is typically \'./producticons/awesome-product-icon-theme.json\'.'
-                        )),
-                        type: 'string'
-                    }
-                },
-                required: ['path', 'id']
+                    required: ['path', 'id']
+                }
             }
-        }
-    }));
+        }))
+    );
 }
 class ThemeRegistry {
     constructor(themesExtPoint, create, idRequired = false, builtInTheme = undefined) {
@@ -2626,7 +2634,7 @@ class ThemeRegistry {
         this.create = create;
         this.idRequired = idRequired;
         this.builtInTheme = builtInTheme;
-        this.onDidChangeEmitter = ( new Emitter());
+        this.onDidChangeEmitter = ( (new Emitter()));
         this.onDidChange = this.onDidChangeEmitter.event;
         this.extensionThemes = [];
         this.initialize();
@@ -2651,47 +2659,47 @@ class ThemeRegistry {
                     delete previousIds[theme.id];
                 }
             }
-            const removed = ( Object.values(previousIds));
+            const removed = ( (Object.values(previousIds)));
             this.onDidChangeEmitter.fire({ themes: this.extensionThemes, added, removed });
         });
     }
     onThemes(extensionData, extensionLocation, themeContributions, resultingThemes = [], log) {
         if (!Array.isArray(themeContributions)) {
-            log?.error(( localize(
+            log?.error(( (localize(
                 'reqarray',
                 "Extension point `{0}` must be an array.",
                 this.themesExtPoint.name
-            )));
+            ))));
             return resultingThemes;
         }
         themeContributions.forEach(theme => {
             if (!theme.path || !isString(theme.path)) {
-                log?.error(( localize(
+                log?.error(( (localize(
                     'reqpath',
                     "Expected string in `contributes.{0}.path`. Provided value: {1}",
                     this.themesExtPoint.name,
                     String(theme.path)
-                )));
+                ))));
                 return;
             }
             if (this.idRequired && (!theme.id || !isString(theme.id))) {
-                log?.error(( localize(
+                log?.error(( (localize(
                     'reqid',
                     "Expected string in `contributes.{0}.id`. Provided value: {1}",
                     this.themesExtPoint.name,
                     String(theme.id)
-                )));
+                ))));
                 return;
             }
             const themeLocation = joinPath(extensionLocation, theme.path);
             if (!isEqualOrParent(themeLocation, extensionLocation)) {
-                log?.warn(( localize(
+                log?.warn(( (localize(
                     'invalid.path.1',
                     "Expected `contributes.{0}.path` ({1}) to be included inside extension's folder ({2}). This might make the extension non-portable.",
                     this.themesExtPoint.name,
                     themeLocation.path,
                     extensionLocation.path
-                )));
+                ))));
             }
             const themeData = this.create(theme, themeLocation, extensionData);
             resultingThemes.push(themeData);
@@ -2753,87 +2761,87 @@ const DEFAULT_THEME_HC_DARK_SETTING_VALUE = 'Default High Contrast';
 const DEFAULT_THEME_HC_LIGHT_SETTING_VALUE = 'Default High Contrast Light';
 const DEFAULT_FILE_ICON_THEME_SETTING_VALUE = 'vs-seti';
 const DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE = 'Default';
-const configurationRegistry = ( Registry.as(Extensions$2.Configuration));
+const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
 const colorThemeSettingEnum = [];
 const colorThemeSettingEnumItemLabels = [];
 const colorThemeSettingEnumDescriptions = [];
 const colorThemeSettingSchema = {
     type: 'string',
-    description: ( localize('colorTheme', "Specifies the color theme used in the workbench.")),
+    description: ( (localize('colorTheme', "Specifies the color theme used in the workbench."))),
     default: isWeb ? DEFAULT_THEME_LIGHT_SETTING_VALUE : DEFAULT_THEME_DARK_SETTING_VALUE,
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
-    errorMessage: ( localize('colorThemeError', "Theme is unknown or not installed.")),
+    errorMessage: ( (localize('colorThemeError', "Theme is unknown or not installed."))),
 };
 const preferredDarkThemeSettingSchema = {
     type: 'string',
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         { key: 'preferredDarkColorTheme', comment: ['`#{0}#` will become a link to an other setting. Do not remove backtick or #'] },
         'Specifies the preferred color theme for dark OS appearance when `#{0}#` is enabled.',
         ThemeSettings.DETECT_COLOR_SCHEME
-    )),
+    ))),
     default: DEFAULT_THEME_DARK_SETTING_VALUE,
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
-    errorMessage: ( localize('colorThemeError', "Theme is unknown or not installed.")),
+    errorMessage: ( (localize('colorThemeError', "Theme is unknown or not installed."))),
 };
 const preferredLightThemeSettingSchema = {
     type: 'string',
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         { key: 'preferredLightColorTheme', comment: ['`#{0}#` will become a link to an other setting. Do not remove backtick or #'] },
         'Specifies the preferred color theme for light OS appearance when `#{0}#` is enabled.',
         ThemeSettings.DETECT_COLOR_SCHEME
-    )),
+    ))),
     default: DEFAULT_THEME_LIGHT_SETTING_VALUE,
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
-    errorMessage: ( localize('colorThemeError', "Theme is unknown or not installed.")),
+    errorMessage: ( (localize('colorThemeError', "Theme is unknown or not installed."))),
 };
 const preferredHCDarkThemeSettingSchema = {
     type: 'string',
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         { key: 'preferredHCDarkColorTheme', comment: ['`#{0}#` will become a link to an other setting. Do not remove backtick or #'] },
         'Specifies the preferred color theme used in high contrast dark mode when `#{0}#` is enabled.',
         ThemeSettings.DETECT_HC
-    )),
+    ))),
     default: DEFAULT_THEME_HC_DARK_SETTING_VALUE,
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
-    errorMessage: ( localize('colorThemeError', "Theme is unknown or not installed.")),
+    errorMessage: ( (localize('colorThemeError', "Theme is unknown or not installed."))),
 };
 const preferredHCLightThemeSettingSchema = {
     type: 'string',
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         { key: 'preferredHCLightColorTheme', comment: ['`#{0}#` will become a link to an other setting. Do not remove backtick or #'] },
         'Specifies the preferred color theme used in high contrast light mode when `#{0}#` is enabled.',
         ThemeSettings.DETECT_HC
-    )),
+    ))),
     default: DEFAULT_THEME_HC_LIGHT_SETTING_VALUE,
     enum: colorThemeSettingEnum,
     enumDescriptions: colorThemeSettingEnumDescriptions,
     enumItemLabels: colorThemeSettingEnumItemLabels,
-    errorMessage: ( localize('colorThemeError', "Theme is unknown or not installed.")),
+    errorMessage: ( (localize('colorThemeError', "Theme is unknown or not installed."))),
 };
 const detectColorSchemeSettingSchema = {
     type: 'boolean',
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         'detectColorScheme',
         'If set, automatically switch to the preferred color theme based on the OS appearance. If the OS appearance is dark, the theme specified at `#{0}#` is used, for light `#{1}#`.',
         ThemeSettings.PREFERRED_DARK_THEME,
         ThemeSettings.PREFERRED_LIGHT_THEME
-    )),
+    ))),
     default: false
 };
 const colorCustomizationsSchema = {
     type: 'object',
-    description: ( localize(
+    description: ( (localize(
         'workbenchColors',
         "Overrides colors from the currently selected color theme."
-    )),
+    ))),
     allOf: [{ $ref: workbenchColorsSchemaId }],
     default: {},
     defaultSnippets: [{
@@ -2843,33 +2851,33 @@ const colorCustomizationsSchema = {
 const fileIconThemeSettingSchema = {
     type: ['string', 'null'],
     default: DEFAULT_FILE_ICON_THEME_SETTING_VALUE,
-    description: ( localize(
+    description: ( (localize(
         'iconTheme',
         "Specifies the file icon theme used in the workbench or 'null' to not show any file icons."
-    )),
+    ))),
     enum: [null],
-    enumItemLabels: [( localize('noIconThemeLabel', 'None'))],
-    enumDescriptions: [( localize('noIconThemeDesc', 'No file icons'))],
-    errorMessage: ( localize('iconThemeError', "File icon theme is unknown or not installed."))
+    enumItemLabels: [( (localize('noIconThemeLabel', 'None')))],
+    enumDescriptions: [( (localize('noIconThemeDesc', 'No file icons')))],
+    errorMessage: ( (localize('iconThemeError', "File icon theme is unknown or not installed.")))
 };
 const productIconThemeSettingSchema = {
     type: ['string', 'null'],
     default: DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE,
-    description: ( localize('productIconTheme', "Specifies the product icon theme used.")),
+    description: ( (localize('productIconTheme', "Specifies the product icon theme used."))),
     enum: [DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE],
-    enumItemLabels: [( localize('defaultProductIconThemeLabel', 'Default'))],
-    enumDescriptions: [( localize('defaultProductIconThemeDesc', 'Default'))],
-    errorMessage: ( localize('productIconThemeError', "Product icon theme is unknown or not installed."))
+    enumItemLabels: [( (localize('defaultProductIconThemeLabel', 'Default')))],
+    enumDescriptions: [( (localize('defaultProductIconThemeDesc', 'Default')))],
+    errorMessage: ( (localize('productIconThemeError', "Product icon theme is unknown or not installed.")))
 };
 const detectHCSchemeSettingSchema = {
     type: 'boolean',
     default: true,
-    markdownDescription: ( localize(
+    markdownDescription: ( (localize(
         'autoDetectHighContrast',
         "If enabled, will automatically change to high contrast theme if the OS is using a high contrast theme. The high contrast theme to use is specified by `#{0}#` and `#{1}#`",
         ThemeSettings.PREFERRED_HC_DARK_THEME,
         ThemeSettings.PREFERRED_HC_LIGHT_THEME
-    )),
+    ))),
     scope: 1
 };
 const themeSettingsConfiguration = {
@@ -2908,52 +2916,52 @@ const themeSpecificSettingKey = '^\\[[^\\]]*(\\]\\s*\\[[^\\]]*)*\\]$';
 const tokenColorSchema = {
     type: 'object',
     properties: {
-        comments: tokenGroupSettings(( localize('editorColors.comments', "Sets the colors and styles for comments"))),
-        strings: tokenGroupSettings(( localize('editorColors.strings', "Sets the colors and styles for strings literals."))),
-        keywords: tokenGroupSettings(( localize('editorColors.keywords', "Sets the colors and styles for keywords."))),
-        numbers: tokenGroupSettings(( localize('editorColors.numbers', "Sets the colors and styles for number literals."))),
-        types: tokenGroupSettings(( localize(
+        comments: tokenGroupSettings(( (localize('editorColors.comments', "Sets the colors and styles for comments")))),
+        strings: tokenGroupSettings(( (localize('editorColors.strings', "Sets the colors and styles for strings literals.")))),
+        keywords: tokenGroupSettings(( (localize('editorColors.keywords', "Sets the colors and styles for keywords.")))),
+        numbers: tokenGroupSettings(( (localize('editorColors.numbers', "Sets the colors and styles for number literals.")))),
+        types: tokenGroupSettings(( (localize(
             'editorColors.types',
             "Sets the colors and styles for type declarations and references."
-        ))),
-        functions: tokenGroupSettings(( localize(
+        )))),
+        functions: tokenGroupSettings(( (localize(
             'editorColors.functions',
             "Sets the colors and styles for functions declarations and references."
-        ))),
-        variables: tokenGroupSettings(( localize(
+        )))),
+        variables: tokenGroupSettings(( (localize(
             'editorColors.variables',
             "Sets the colors and styles for variables declarations and references."
-        ))),
+        )))),
         textMateRules: {
-            description: ( localize(
+            description: ( (localize(
                 'editorColors.textMateRules',
                 'Sets colors and styles using textmate theming rules (advanced).'
-            )),
+            ))),
             $ref: textmateColorsSchemaId
         },
         semanticHighlighting: {
-            description: ( localize(
+            description: ( (localize(
                 'editorColors.semanticHighlighting',
                 'Whether semantic highlighting should be enabled for this theme.'
-            )),
-            deprecationMessage: ( localize(
+            ))),
+            deprecationMessage: ( (localize(
                 'editorColors.semanticHighlighting.deprecationMessage',
                 'Use `enabled` in `editor.semanticTokenColorCustomizations` setting instead.'
-            )),
-            markdownDeprecationMessage: ( localize(
+            ))),
+            markdownDeprecationMessage: ( (localize(
                 'editorColors.semanticHighlighting.deprecationMessageMarkdown',
                 'Use `enabled` in `#editor.semanticTokenColorCustomizations#` setting instead.'
-            )),
+            ))),
             type: 'boolean'
         }
     },
     additionalProperties: false
 };
 const tokenColorCustomizationSchema = {
-    description: ( localize(
+    description: ( (localize(
         'editorColors',
         "Overrides editor syntax colors and font style from the currently selected color theme."
-    )),
+    ))),
     default: {},
     allOf: [{ ...tokenColorSchema, patternProperties: { '^\\[': {} } }]
 };
@@ -2962,28 +2970,28 @@ const semanticTokenColorSchema = {
     properties: {
         enabled: {
             type: 'boolean',
-            description: ( localize(
+            description: ( (localize(
                 'editorColors.semanticHighlighting.enabled',
                 'Whether semantic highlighting is enabled or disabled for this theme'
-            )),
+            ))),
             suggestSortText: '0_enabled'
         },
         rules: {
             $ref: tokenStylingSchemaId,
-            description: ( localize(
+            description: ( (localize(
                 'editorColors.semanticHighlighting.rules',
                 'Semantic token styling rules for this theme.'
-            )),
+            ))),
             suggestSortText: '0_rules'
         }
     },
     additionalProperties: false
 };
 const semanticTokenColorCustomizationSchema = {
-    description: ( localize(
+    description: ( (localize(
         'semanticTokenColors',
         "Overrides editor semantic token color and styles from the currently selected color theme."
-    )),
+    ))),
     default: {},
     allOf: [{ ...semanticTokenColorSchema, patternProperties: { '^\\[': {} } }]
 };
@@ -3113,7 +3121,7 @@ class ThemeConfiguration {
 const DEFAULT_PRODUCT_ICON_THEME_ID = '';
 class ProductIconThemeData {
     constructor(id, label, settingsId) {
-        this.iconThemeDocument = { iconDefinitions: ( new Map()) };
+        this.iconThemeDocument = { iconDefinitions: ( (new Map())) };
         this.id = id;
         this.label = label;
         this.settingsId = settingsId;
@@ -3137,12 +3145,12 @@ class ProductIconThemeData {
         this.iconThemeDocument = await _loadProductIconThemeDocument(fileService, location, warnings);
         this.isLoaded = true;
         if (warnings.length) {
-            logService.error(( localize(
+            logService.error(( (localize(
                 'error.parseicondefs',
                 "Problems processing product icons definitions in {0}:\n{1}",
-                ( location.toString()),
+                 (location.toString()),
                 warnings.join('\n')
-            )));
+            ))));
         }
         return this.styleSheetContent;
     }
@@ -3150,7 +3158,7 @@ class ProductIconThemeData {
         const id = extensionData.extensionId + '-' + iconTheme.id;
         const label = iconTheme.label || basename(iconTheme.path);
         const settingsId = iconTheme.id;
-        const themeData = ( new ProductIconThemeData(id, label, settingsId));
+        const themeData = ( (new ProductIconThemeData(id, label, settingsId)));
         themeData.description = iconTheme.description;
         themeData.location = iconThemeLocation;
         themeData.extensionData = extensionData;
@@ -3159,7 +3167,7 @@ class ProductIconThemeData {
         return themeData;
     }
     static createUnloadedTheme(id) {
-        const themeData = ( new ProductIconThemeData(id, '', '__' + id));
+        const themeData = ( (new ProductIconThemeData(id, '', '__' + id)));
         themeData.isLoaded = false;
         themeData.extensionData = undefined;
         themeData.watch = false;
@@ -3168,7 +3176,11 @@ class ProductIconThemeData {
     static get defaultTheme() {
         let themeData = ProductIconThemeData._defaultProductIconTheme;
         if (!themeData) {
-            themeData = ProductIconThemeData._defaultProductIconTheme = ( new ProductIconThemeData(DEFAULT_PRODUCT_ICON_THEME_ID, ( localize('defaultTheme', 'Default')), DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE));
+            themeData = ProductIconThemeData._defaultProductIconTheme = ( (new ProductIconThemeData(
+                DEFAULT_PRODUCT_ICON_THEME_ID,
+                 (localize('defaultTheme', 'Default')),
+                DEFAULT_PRODUCT_ICON_THEME_SETTING_VALUE
+            )));
             themeData.isLoaded = true;
             themeData.extensionData = undefined;
             themeData.watch = false;
@@ -3182,7 +3194,7 @@ class ProductIconThemeData {
         }
         try {
             const data = JSON.parse(input);
-            const theme = ( new ProductIconThemeData('', '', ''));
+            const theme = ( (new ProductIconThemeData('', '', '')));
             for (const key in data) {
                 switch (key) {
                     case 'id':
@@ -3202,7 +3214,7 @@ class ProductIconThemeData {
             }
             const { iconDefinitions, iconFontDefinitions } = data;
             if (Array.isArray(iconDefinitions) && isObject(iconFontDefinitions)) {
-                const restoredIconDefinitions = ( new Map());
+                const restoredIconDefinitions = ( (new Map()));
                 for (const entry of iconDefinitions) {
                     const { id, fontCharacter, fontId } = entry;
                     if (isString(id) && isString(fontCharacter)) {
@@ -3256,26 +3268,26 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
         const parseErrors = [];
         const contentValue = parse$1(content, parseErrors);
         if (parseErrors.length > 0) {
-            return Promise.reject(( new Error(( localize(
+            return Promise.reject(( (new Error( (localize(
                 'error.cannotparseicontheme',
                 "Problems parsing product icons file: {0}",
                 parseErrors.map(e => getParseErrorMessage(e.error)).join(', ')
-            )))));
+            ))))));
         }
         else if (getNodeType(contentValue) !== 'object') {
-            return Promise.reject(( new Error(( localize(
+            return Promise.reject(( (new Error( (localize(
                 'error.invalidformat',
                 "Invalid format for product icons theme file: Object expected."
-            )))));
+            ))))));
         }
         else if (!contentValue.iconDefinitions || !Array.isArray(contentValue.fonts) || !contentValue.fonts.length) {
-            return Promise.reject(( new Error(( localize(
+            return Promise.reject(( (new Error( (localize(
                 'error.missingProperties',
                 "Invalid format for product icons theme file: Must contain iconDefinitions and fonts."
-            )))));
+            ))))));
         }
         const iconThemeDocumentLocationDirname = dirname(location);
-        const sanitizedFonts = ( new Map());
+        const sanitizedFonts = ( (new Map()));
         for (const font of contentValue.fonts) {
             if (isString(font.id) && font.id.match(fontIdRegex)) {
                 const fontId = font.id;
@@ -3284,22 +3296,22 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                     fontWeight = font.weight;
                 }
                 else {
-                    warnings.push(( localize(
+                    warnings.push(( (localize(
                         'error.fontWeight',
                         'Invalid font weight in font \'{0}\'. Ignoring setting.',
                         font.id
-                    )));
+                    ))));
                 }
                 let fontStyle = undefined;
                 if (isString(font.style) && font.style.match(fontStyleRegex)) {
                     fontStyle = font.style;
                 }
                 else {
-                    warnings.push(( localize(
+                    warnings.push(( (localize(
                         'error.fontStyle',
                         'Invalid font style in font \'{0}\'. Ignoring setting.',
                         font.id
-                    )));
+                    ))));
                 }
                 const sanitizedSrc = [];
                 if (Array.isArray(font.src)) {
@@ -3309,11 +3321,11 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                             sanitizedSrc.push({ location: iconFontLocation, format: s.format });
                         }
                         else {
-                            warnings.push(( localize(
+                            warnings.push(( (localize(
                                 'error.fontSrc',
                                 'Invalid font source in font \'{0}\'. Ignoring source.',
                                 font.id
-                            )));
+                            ))));
                         }
                     }
                 }
@@ -3321,22 +3333,22 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                     sanitizedFonts.set(fontId, { weight: fontWeight, style: fontStyle, src: sanitizedSrc });
                 }
                 else {
-                    warnings.push(( localize(
+                    warnings.push(( (localize(
                         'error.noFontSrc',
                         'No valid font source in font \'{0}\'. Ignoring font definition.',
                         font.id
-                    )));
+                    ))));
                 }
             }
             else {
-                warnings.push(( localize(
+                warnings.push(( (localize(
                     'error.fontId',
                     'Missing or invalid font id \'{0}\'. Skipping font definition.',
                     font.id
-                )));
+                ))));
             }
         }
-        const iconDefinitions = ( new Map());
+        const iconDefinitions = ( (new Map()));
         const primaryFontId = contentValue.fonts[0].id;
         for (const iconId in contentValue.iconDefinitions) {
             const definition = contentValue.iconDefinitions[iconId];
@@ -3348,19 +3360,19 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                     iconDefinitions.set(iconId, { fontCharacter: definition.fontCharacter, font });
                 }
                 else {
-                    warnings.push(( localize(
+                    warnings.push(( (localize(
                         'error.icon.font',
                         'Skipping icon definition \'{0}\'. Unknown font.',
                         iconId
-                    )));
+                    ))));
                 }
             }
             else {
-                warnings.push(( localize(
+                warnings.push(( (localize(
                     'error.icon.fontCharacter',
                     'Skipping icon definition \'{0}\'. Unknown fontCharacter.',
                     iconId
-                )));
+                ))));
             }
         }
         return { iconDefinitions };
@@ -3399,7 +3411,7 @@ const fileIconsEnabledClass = 'file-icons-enabled';
 const colorThemeRulesClassName = 'contributedColorTheme';
 const fileIconThemeRulesClassName = 'contributedFileIconTheme';
 const productIconThemeRulesClassName = 'contributedProductIconTheme';
-const themingRegistry = ( Registry.as(Extensions$3.ThemingContribution));
+const themingRegistry = ( (Registry.as(Extensions$3.ThemingContribution)));
 function validateThemeId(theme) {
     switch (theme) {
         case VS_LIGHT_THEME: return `vs ${defaultThemeExtensionId}-themes-light_vs-json`;
@@ -3424,43 +3436,43 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         this.hostColorService = hostColorService;
         this.userDataInitializationService = userDataInitializationService;
         this.languageService = languageService;
-        this.themeExtensionsActivated = ( new Map());
+        this.themeExtensionsActivated = ( (new Map()));
         this.container = layoutService.container;
-        this.settings = ( new ThemeConfiguration(configurationService));
-        this.colorThemeRegistry = ( new ThemeRegistry(colorThemesExtPoint, ColorThemeData.fromExtensionTheme));
-        this.colorThemeWatcher = ( new ThemeFileWatcher(fileService, environmentService, this.reloadCurrentColorTheme.bind(this)));
-        this.onColorThemeChange = ( new Emitter({ leakWarningThreshold: 400 }));
+        this.settings = ( (new ThemeConfiguration(configurationService)));
+        this.colorThemeRegistry = ( (new ThemeRegistry(colorThemesExtPoint, ColorThemeData.fromExtensionTheme)));
+        this.colorThemeWatcher = ( (new ThemeFileWatcher(fileService, environmentService, this.reloadCurrentColorTheme.bind(this))));
+        this.onColorThemeChange = ( (new Emitter({ leakWarningThreshold: 400 })));
         this.currentColorTheme = ColorThemeData.createUnloadedTheme('');
-        this.colorThemeSequencer = ( new Sequencer());
-        this.fileIconThemeWatcher = ( new ThemeFileWatcher(
+        this.colorThemeSequencer = ( (new Sequencer()));
+        this.fileIconThemeWatcher = ( (new ThemeFileWatcher(
             fileService,
             environmentService,
             this.reloadCurrentFileIconTheme.bind(this)
-        ));
-        this.fileIconThemeRegistry = ( new ThemeRegistry(
+        )));
+        this.fileIconThemeRegistry = ( (new ThemeRegistry(
             fileIconThemesExtPoint,
             FileIconThemeData.fromExtensionTheme,
             true,
             FileIconThemeData.noIconTheme
-        ));
-        this.fileIconThemeLoader = ( new FileIconThemeLoader(extensionResourceLoaderService, languageService));
-        this.onFileIconThemeChange = ( new Emitter({ leakWarningThreshold: 400 }));
+        )));
+        this.fileIconThemeLoader = ( (new FileIconThemeLoader(extensionResourceLoaderService, languageService)));
+        this.onFileIconThemeChange = ( (new Emitter({ leakWarningThreshold: 400 })));
         this.currentFileIconTheme = FileIconThemeData.createUnloadedTheme('');
-        this.fileIconThemeSequencer = ( new Sequencer());
-        this.productIconThemeWatcher = ( new ThemeFileWatcher(
+        this.fileIconThemeSequencer = ( (new Sequencer()));
+        this.productIconThemeWatcher = ( (new ThemeFileWatcher(
             fileService,
             environmentService,
             this.reloadCurrentProductIconTheme.bind(this)
-        ));
-        this.productIconThemeRegistry = ( new ThemeRegistry(
+        )));
+        this.productIconThemeRegistry = ( (new ThemeRegistry(
             productIconThemesExtPoint,
             ProductIconThemeData.fromExtensionTheme,
             true,
             ProductIconThemeData.defaultTheme
-        ));
-        this.onProductIconThemeChange = ( new Emitter());
+        )));
+        this.onProductIconThemeChange = ( (new Emitter()));
         this.currentProductIconTheme = ProductIconThemeData.createUnloadedTheme('');
-        this.productIconThemeSequencer = ( new Sequencer());
+        this.productIconThemeSequencer = ( (new Sequencer()));
         let themeData = ColorThemeData.fromStorageData(this.storageService);
         if (themeData && this.settings.colorTheme !== themeData.settingsId && this.settings.isDefaultColorTheme()) {
             themeData = undefined;
@@ -3500,7 +3512,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         function updateAll() {
             codiconStyleSheet.textContent = iconsStyleSheet.getCSS();
         }
-        const delayer = ( new RunOnceScheduler(updateAll, 0));
+        const delayer = ( (new RunOnceScheduler(updateAll, 0)));
         iconsStyleSheet.onDidChange(() => delayer.schedule());
         delayer.schedule();
     }
@@ -3799,7 +3811,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         });
     }
     updateDynamicCSSRules(themeData) {
-        const cssRules = ( new Set());
+        const cssRules = ( (new Set()));
         const ruleCollector = {
             addRule: (rule) => {
                 if (!cssRules.has(rule)) {
@@ -3813,7 +3825,7 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         for (const item of getColorRegistry().getColors()) {
             const color = themeData.getColor(item.id, true);
             if (color) {
-                colorVariables.push(`${asCssVariableName(item.id)}: ${( color.toString())};`);
+                colorVariables.push(`${asCssVariableName(item.id)}: ${( ( color.toString()))};`);
             }
         }
         ruleCollector.addRule(`.monaco-workbench { ${colorVariables.join('\n')} }`);
@@ -4034,20 +4046,20 @@ let WorkbenchThemeService = class WorkbenchThemeService {
         }
     }
 };
-WorkbenchThemeService = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IBrowserWorkbenchEnvironmentService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IExtensionResourceLoaderService)),
-    ( __param(7, IWorkbenchLayoutService)),
-    ( __param(8, ILogService)),
-    ( __param(9, IHostColorSchemeService)),
-    ( __param(10, IUserDataInitializationService)),
-    ( __param(11, ILanguageService))
-], WorkbenchThemeService));
+WorkbenchThemeService = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IStorageService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, ITelemetryService))),
+    ( (__param(4, IBrowserWorkbenchEnvironmentService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, IExtensionResourceLoaderService))),
+    ( (__param(7, IWorkbenchLayoutService))),
+    ( (__param(8, ILogService))),
+    ( (__param(9, IHostColorSchemeService))),
+    ( (__param(10, IUserDataInitializationService))),
+    ( (__param(11, ILanguageService)))
+], WorkbenchThemeService)));
 class ThemeFileWatcher {
     constructor(fileService, environmentService, onUpdate) {
         this.fileService = fileService;
@@ -4109,7 +4121,7 @@ const DEFAULT_THEME_EXTENSION = {
     isBuiltin: true,
     isUserBuiltin: true,
     isUnderDevelopment: false,
-    extensionLocation: URI.from({ scheme: 'extension', path: '/' }),
+    extensionLocation: ( URI.from({ scheme: 'extension', path: '/' })),
     name: 'theme-defaults',
     publisher: 'vscode',
     version: '1.0.0',
@@ -4150,7 +4162,7 @@ function setDefaultThemes(_themes, getContent) {
 function getServiceOverride() {
     return {
         ...getServiceOverride$1(),
-        [IThemeService.toString()]: new SyncDescriptor(StandaloneWorkbenchThemeService)
+        [( IThemeService.toString())]: new SyncDescriptor(StandaloneWorkbenchThemeService)
     };
 }
 export { getServiceOverride as default, setDefaultThemes, setThemes };