@codingame/monaco-vscode-api 1.69.8 → 1.69.9

package/dist/tokenClassification.js

@@ -1,10 +1,10 @@
 import './polyfill.js';
-import { E as ExtensionsRegistry, m as ExtensionMessageCollector } from './missing-services.js';
+import { j as ExtensionMessageCollector, E as ExtensionsRegistry } from './missing-services.js';
 import { g as getTokenClassificationRegistry, a as typeAndModifierIdPattern } from './tokenClassificationRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { g as getExtensionPoint, o as onServicesInitialized, c as consoleExtensionMessageHandler } from './tools.js';
+import { g as getExtensionPoint, c as consoleExtensionMessageHandler, o as onServicesInitialized } from './tools.js';
 import { S as Services } from './services2.js';
-import { D as DEFAULT_EXTENSION } from './extHost.js';
+import { bd as DEFAULT_EXTENSION } from './extHost.js';
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenTypeExtPoint$1 = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenTypes',

package/dist/tokenClassificationRegistry.js

@@ -20,7 +20,7 @@ class TokenStyle {
         this.italic = italic;
     }
 }
-( (function(TokenStyle) {
+( ((function(TokenStyle) {
     function toJSONObject(style) {
         return {
             _foreground: style.foreground === undefined ? null : Color.Format.CSS.formatHexA(style.foreground, true),
@@ -34,14 +34,16 @@ class TokenStyle {
     function fromJSONObject(obj) {
         if (obj) {
             const boolOrUndef = (b) => (typeof b === 'boolean') ? b : undefined;
-            const colorOrUndef = (s) => (typeof s === 'string') ? ( Color.fromHex(s)) : undefined;
-            return ( new TokenStyle(
-                colorOrUndef(obj._foreground),
-                boolOrUndef(obj._bold),
-                boolOrUndef(obj._underline),
-                boolOrUndef(obj._strikethrough),
-                boolOrUndef(obj._italic)
-            ));
+            const colorOrUndef = (s) => (typeof s === 'string') ? ( (Color.fromHex(s))) : undefined;
+            return (
+                 (new TokenStyle(
+                    colorOrUndef(obj._foreground),
+                    boolOrUndef(obj._bold),
+                    boolOrUndef(obj._underline),
+                    boolOrUndef(obj._strikethrough),
+                    boolOrUndef(obj._italic)
+                ))
+            );
         }
         return undefined;
     }
@@ -63,19 +65,21 @@ class TokenStyle {
     }
     TokenStyle.is = is;
     function fromData(data) {
-        return ( new TokenStyle(
-            data.foreground,
-            data.bold,
-            data.underline,
-            data.strikethrough,
-            data.italic
-        ));
+        return (
+             (new TokenStyle(
+                data.foreground,
+                data.bold,
+                data.underline,
+                data.strikethrough,
+                data.italic
+            ))
+        );
     }
     TokenStyle.fromData = fromData;
     function fromSettings(foreground, fontStyle, bold, underline, strikethrough, italic) {
         let foregroundColor = undefined;
         if (foreground !== undefined) {
-            foregroundColor = ( Color.fromHex(foreground));
+            foregroundColor = ( (Color.fromHex(foreground)));
         }
         if (fontStyle !== undefined) {
             bold = italic = underline = strikethrough = false;
@@ -98,12 +102,14 @@ class TokenStyle {
                 }
             }
         }
-        return ( new TokenStyle(foregroundColor, bold, underline, strikethrough, italic));
+        return (
+             (new TokenStyle(foregroundColor, bold, underline, strikethrough, italic))
+        );
     }
     TokenStyle.fromSettings = fromSettings;
-})(TokenStyle || (TokenStyle = {})));
+})(TokenStyle || (TokenStyle = {}))));
 var SemanticTokenRule;
-( (function(SemanticTokenRule) {
+( ((function(SemanticTokenRule) {
     function fromJSONObject(registry, o) {
         if (o && typeof o._selector === 'string' && o._style) {
             const style = TokenStyle.fromJSONObject(o._style);
@@ -138,10 +144,10 @@ var SemanticTokenRule;
         return r && r.selector && typeof r.selector.id === 'string' && TokenStyle.is(r.style);
     }
     SemanticTokenRule.is = is;
-})(SemanticTokenRule || (SemanticTokenRule = {})));
+})(SemanticTokenRule || (SemanticTokenRule = {}))));
 class TokenClassificationRegistry {
     constructor() {
-        this._onDidChangeSchema = ( new Emitter());
+        this._onDidChangeSchema = ( (new Emitter()));
         this.onDidChangeSchema = this._onDidChangeSchema.event;
         this.currentTypeNumber = 0;
         this.currentModifierBit = 1;
@@ -156,34 +162,34 @@ class TokenClassificationRegistry {
             definitions: {
                 style: {
                     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',
                                 'Sets the all font styles of the rule: \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. All styles that are not listed are unset. The empty string unsets all styles.'
-                            )),
+                            ))),
                             pattern: fontStylePattern,
-                            patternErrorMessage: ( localize(
+                            patternErrorMessage: ( (localize(
                                 'schema.fontStyle.error',
                                 'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'
-                            )),
+                            ))),
                             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' },
@@ -203,31 +209,31 @@ class TokenClassificationRegistry {
                         },
                         bold: {
                             type: 'boolean',
-                            description: ( localize(
+                            description: ( (localize(
                                 'schema.token.bold',
                                 'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         italic: {
                             type: 'boolean',
-                            description: ( localize(
+                            description: ( (localize(
                                 'schema.token.italic',
                                 'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         underline: {
                             type: 'boolean',
-                            description: ( localize(
+                            description: ( (localize(
                                 'schema.token.underline',
                                 'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         strikethrough: {
                             type: 'boolean',
-                            description: ( localize(
+                            description: ( (localize(
                                 'schema.token.strikethrough',
                                 'Sets or unsets the font style to strikethrough. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         }
                     },
                     defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
@@ -314,10 +320,10 @@ class TokenClassificationRegistry {
         delete this.tokenStylingSchema.properties[`*.${id}`];
     }
     getTokenTypes() {
-        return ( Object.keys(this.tokenTypeById)).map(id => this.tokenTypeById[id]);
+        return ( (Object.keys(this.tokenTypeById))).map(id => this.tokenTypeById[id]);
     }
     getTokenModifiers() {
-        return ( Object.keys(this.tokenModifierById)).map(id => this.tokenModifierById[id]);
+        return ( (Object.keys(this.tokenModifierById))).map(id => this.tokenModifierById[id]);
     }
     getTokenStylingSchema() {
         return this.tokenStylingSchema;
@@ -346,7 +352,7 @@ class TokenClassificationRegistry {
             }
             return a.localeCompare(b);
         };
-        return ( Object.keys(this.tokenTypeById)).sort(sorter).map(k => `- \`${k}\`: ${this.tokenTypeById[k].description}`).join('\n');
+        return ( (Object.keys(this.tokenTypeById))).sort(sorter).map(k => `- \`${k}\`: ${this.tokenTypeById[k].description}`).join('\n');
     }
 }
 const CHAR_LANGUAGE = TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR.charCodeAt(0);
@@ -373,7 +379,7 @@ function parseClassifierString(s, defaultLanguage) {
 }
 const tokenClassificationRegistry = createDefaultTokenClassificationRegistry();
 function createDefaultTokenClassificationRegistry() {
-    const registry = ( new TokenClassificationRegistry());
+    const registry = ( (new TokenClassificationRegistry()));
     function registerTokenType(id, description, scopesToProbe = [], superType, deprecationMessage) {
         registry.registerTokenType(id, description, superType, deprecationMessage);
         if (scopesToProbe) {
@@ -390,38 +396,38 @@ function createDefaultTokenClassificationRegistry() {
             console.log(e);
         }
     }
-    registerTokenType('comment', ( localize('comment', "Style for comments.")), [['comment']]);
-    registerTokenType('string', ( localize('string', "Style for strings.")), [['string']]);
-    registerTokenType('keyword', ( localize('keyword', "Style for keywords.")), [['keyword.control']]);
-    registerTokenType('number', ( localize('number', "Style for numbers.")), [['constant.numeric']]);
-    registerTokenType('regexp', ( localize('regexp', "Style for expressions.")), [['constant.regexp']]);
-    registerTokenType('operator', ( localize('operator', "Style for operators.")), [['keyword.operator']]);
-    registerTokenType('namespace', ( localize('namespace', "Style for namespaces.")), [['entity.name.namespace']]);
-    registerTokenType('type', ( localize('type', "Style for types.")), [['entity.name.type'], ['support.type']]);
-    registerTokenType('struct', ( localize('struct', "Style for structs.")), [['entity.name.type.struct']]);
-    registerTokenType('class', ( localize('class', "Style for classes.")), [['entity.name.type.class'], ['support.class']]);
-    registerTokenType('interface', ( localize('interface', "Style for interfaces.")), [['entity.name.type.interface']]);
-    registerTokenType('enum', ( localize('enum', "Style for enums.")), [['entity.name.type.enum']]);
-    registerTokenType('typeParameter', ( localize('typeParameter', "Style for type parameters.")), [['entity.name.type.parameter']]);
-    registerTokenType('function', ( localize('function', "Style for functions")), [['entity.name.function'], ['support.function']]);
-    registerTokenType('member', ( localize('member', "Style for member functions")), [], 'method', 'Deprecated use `method` instead');
-    registerTokenType('method', ( localize('method', "Style for method (member functions)")), [['entity.name.function.member'], ['support.function']]);
-    registerTokenType('macro', ( localize('macro', "Style for macros.")), [['entity.name.function.preprocessor']]);
-    registerTokenType('variable', ( localize('variable', "Style for variables.")), [['variable.other.readwrite'], ['entity.name.variable']]);
-    registerTokenType('parameter', ( localize('parameter', "Style for parameters.")), [['variable.parameter']]);
-    registerTokenType('property', ( localize('property', "Style for properties.")), [['variable.other.property']]);
-    registerTokenType('enumMember', ( localize('enumMember', "Style for enum members.")), [['variable.other.enummember']]);
-    registerTokenType('event', ( localize('event', "Style for events.")), [['variable.other.event']]);
-    registerTokenType('decorator', ( localize('decorator', "Style for decorators & annotations.")), [['entity.name.decorator'], ['entity.name.function']]);
-    registerTokenType('label', ( localize('labels', "Style for labels. ")), undefined);
-    registry.registerTokenModifier('declaration', ( localize('declaration', "Style for all symbol declarations.")), undefined);
-    registry.registerTokenModifier('documentation', ( localize('documentation', "Style to use for references in documentation.")), undefined);
-    registry.registerTokenModifier('static', ( localize('static', "Style to use for symbols that are static.")), undefined);
-    registry.registerTokenModifier('abstract', ( localize('abstract', "Style to use for symbols that are abstract.")), undefined);
-    registry.registerTokenModifier('deprecated', ( localize('deprecated', "Style to use for symbols that are deprecated.")), undefined);
-    registry.registerTokenModifier('modification', ( localize('modification', "Style to use for write accesses.")), undefined);
-    registry.registerTokenModifier('async', ( localize('async', "Style to use for symbols that are async.")), undefined);
-    registry.registerTokenModifier('readonly', ( localize('readonly', "Style to use for symbols that are readonly.")), undefined);
+    registerTokenType('comment', ( (localize('comment', "Style for comments."))), [['comment']]);
+    registerTokenType('string', ( (localize('string', "Style for strings."))), [['string']]);
+    registerTokenType('keyword', ( (localize('keyword', "Style for keywords."))), [['keyword.control']]);
+    registerTokenType('number', ( (localize('number', "Style for numbers."))), [['constant.numeric']]);
+    registerTokenType('regexp', ( (localize('regexp', "Style for expressions."))), [['constant.regexp']]);
+    registerTokenType('operator', ( (localize('operator', "Style for operators."))), [['keyword.operator']]);
+    registerTokenType('namespace', ( (localize('namespace', "Style for namespaces."))), [['entity.name.namespace']]);
+    registerTokenType('type', ( (localize('type', "Style for types."))), [['entity.name.type'], ['support.type']]);
+    registerTokenType('struct', ( (localize('struct', "Style for structs."))), [['entity.name.type.struct']]);
+    registerTokenType('class', ( (localize('class', "Style for classes."))), [['entity.name.type.class'], ['support.class']]);
+    registerTokenType('interface', ( (localize('interface', "Style for interfaces."))), [['entity.name.type.interface']]);
+    registerTokenType('enum', ( (localize('enum', "Style for enums."))), [['entity.name.type.enum']]);
+    registerTokenType('typeParameter', ( (localize('typeParameter', "Style for type parameters."))), [['entity.name.type.parameter']]);
+    registerTokenType('function', ( (localize('function', "Style for functions"))), [['entity.name.function'], ['support.function']]);
+    registerTokenType('member', ( (localize('member', "Style for member functions"))), [], 'method', 'Deprecated use `method` instead');
+    registerTokenType('method', ( (localize('method', "Style for method (member functions)"))), [['entity.name.function.member'], ['support.function']]);
+    registerTokenType('macro', ( (localize('macro', "Style for macros."))), [['entity.name.function.preprocessor']]);
+    registerTokenType('variable', ( (localize('variable', "Style for variables."))), [['variable.other.readwrite'], ['entity.name.variable']]);
+    registerTokenType('parameter', ( (localize('parameter', "Style for parameters."))), [['variable.parameter']]);
+    registerTokenType('property', ( (localize('property', "Style for properties."))), [['variable.other.property']]);
+    registerTokenType('enumMember', ( (localize('enumMember', "Style for enum members."))), [['variable.other.enummember']]);
+    registerTokenType('event', ( (localize('event', "Style for events."))), [['variable.other.event']]);
+    registerTokenType('decorator', ( (localize('decorator', "Style for decorators & annotations."))), [['entity.name.decorator'], ['entity.name.function']]);
+    registerTokenType('label', ( (localize('labels', "Style for labels. "))), undefined);
+    registry.registerTokenModifier('declaration', ( (localize('declaration', "Style for all symbol declarations."))), undefined);
+    registry.registerTokenModifier('documentation', ( (localize('documentation', "Style to use for references in documentation."))), undefined);
+    registry.registerTokenModifier('static', ( (localize('static', "Style to use for symbols that are static."))), undefined);
+    registry.registerTokenModifier('abstract', ( (localize('abstract', "Style to use for symbols that are abstract."))), undefined);
+    registry.registerTokenModifier('deprecated', ( (localize('deprecated', "Style to use for symbols that are deprecated."))), undefined);
+    registry.registerTokenModifier('modification', ( (localize('modification', "Style to use for write accesses."))), undefined);
+    registry.registerTokenModifier('async', ( (localize('async', "Style to use for symbols that are async."))), undefined);
+    registry.registerTokenModifier('readonly', ( (localize('readonly', "Style to use for symbols that are readonly."))), undefined);
     registerTokenStyleDefault('variable.readonly', [['variable.other.constant']]);
     registerTokenStyleDefault('property.readonly', [['variable.other.constant.property']]);
     registerTokenStyleDefault('type.defaultLibrary', [['support.type']]);
@@ -455,9 +461,9 @@ function getStylingSchemeEntry(description, deprecationMessage) {
     };
 }
 const tokenStylingSchemaId = 'vscode://schemas/token-styling';
-const schemaRegistry = Registry.as(Extensions.JSONContribution);
+const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
 schemaRegistry.registerSchema(tokenStylingSchemaId, tokenClassificationRegistry.getTokenStylingSchema());
-const delayer = ( new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(tokenStylingSchemaId), 200));
+const delayer = ( (new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(tokenStylingSchemaId), 200)));
 tokenClassificationRegistry.onDidChangeSchema(() => {
     if (!delayer.isScheduled()) {
         delayer.schedule();

package/dist/workbenchThemeService.js

@@ -43,4 +43,4 @@ var ExtensionData;
     }
     ExtensionData.fromName = fromName;
 })(ExtensionData || (ExtensionData = {})));
-export { ExtensionData as E, IWorkbenchThemeService as I, THEME_SCOPE_OPEN_PAREN as T, VS_HC_LIGHT_THEME as V, THEME_SCOPE_CLOSE_PAREN as a, THEME_SCOPE_WILDCARD as b, VS_HC_THEME as c, VS_LIGHT_THEME as d, VS_DARK_THEME as e, ThemeSettings as f, themeScopeRegex as t };
+export { ExtensionData as E, IWorkbenchThemeService as I, ThemeSettings as T, VS_DARK_THEME as V, VS_LIGHT_THEME as a, VS_HC_THEME as b, VS_HC_LIGHT_THEME as c, THEME_SCOPE_OPEN_PAREN as d, THEME_SCOPE_CLOSE_PAREN as e, THEME_SCOPE_WILDCARD as f, themeScopeRegex as t };

package/dist/workspaceContext.js

@@ -44,7 +44,7 @@ class SimpleWorkspaceContextService {
 }
 function getServiceOverride() {
     return {
-        [IWorkspaceContextService.toString()]: new SyncDescriptor(SimpleWorkspaceContextService)
+        [( IWorkspaceContextService.toString())]: new SyncDescriptor(SimpleWorkspaceContextService)
     };
 }
 export { getServiceOverride as g };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.69.8",
+  "version": "1.69.9",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],