@codingame/monaco-vscode-api 1.69.8 → 1.69.9

package/dist/textmate.js

@@ -1,14 +1,14 @@
-import { b as __decorate, d as __param } from './contextkey.js';
+import { _ as __decorate, a as __param } from './contextkey.js';
 import { E as Emitter } from './polyfill.js';
-import { E as ExtensionsRegistry, n as ITextMateService, m as ExtensionMessageCollector } from './missing-services.js';
+import { j as ExtensionMessageCollector, n as ITextMateService, E as ExtensionsRegistry } from './missing-services.js';
 export { n as ITextMateService } from './missing-services.js';
 import { l as languagesExtPoint } from './languageService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { I as IWorkbenchThemeService } from './workbenchThemeService.js';
 import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isEqual, joinPath, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { I as IExtensionResourceLoaderService, g as getServiceOverride$1, r as registerExtensionFile } from './files.js';
-import { EncodedTokenizationResult, TokenizationRegistry } from 'monaco-editor/esm/vs/editor/common/languages.js';
+import { joinPath, isEqualOrParent, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { r as registerExtensionFile, g as getServiceOverride$1, I as IExtensionResourceLoaderService } from './files.js';
+import { TokenizationRegistry, EncodedTokenizationResult } from 'monaco-editor/esm/vs/editor/common/languages.js';
 import { TokenMetadata } from 'monaco-editor/esm/vs/editor/common/encodedTokenAttributes.js';
 import { createStyleSheet } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -22,20 +22,20 @@ import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { nullTokenizeEncoded } from 'monaco-editor/esm/vs/editor/common/languages/nullTokenize.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';
 import { c as createInjectedClass } from './injection.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const grammarsExtPoint = ( (ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'grammars',
     deps: [languagesExtPoint],
     jsonSchema: {
-        description: ( localize(
+        description: ( (localize(
             'vscode.extension.contributes.grammars',
             'Contributes textmate tokenizers.'
-        )),
+        ))),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' }] }],
         items: {
@@ -43,58 +43,58 @@ const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             defaultSnippets: [{ body: { language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' } }],
             properties: {
                 language: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.language',
                         'Language identifier for which this syntax is contributed to.'
-                    )),
+                    ))),
                     type: 'string'
                 },
                 scopeName: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.scopeName',
                         'Textmate scope name used by the tmLanguage file.'
-                    )),
+                    ))),
                     type: 'string'
                 },
                 path: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.path',
                         'Path of the tmLanguage file. The path is relative to the extension folder and typically starts with \'./syntaxes/\'.'
-                    )),
+                    ))),
                     type: 'string'
                 },
                 embeddedLanguages: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.embeddedLanguages',
                         'A map of scope name to language id if this grammar contains embedded languages.'
-                    )),
+                    ))),
                     type: 'object'
                 },
                 tokenTypes: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.tokenTypes',
                         'A map of scope name to token types.'
-                    )),
+                    ))),
                     type: 'object',
                     additionalProperties: {
                         enum: ['string', 'comment', 'other']
                     }
                 },
                 injectTo: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.injectTo',
                         'List of language scope names to which this grammar is injected to.'
-                    )),
+                    ))),
                     type: 'array',
                     items: {
                         type: 'string'
                     }
                 },
                 balancedBracketScopes: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.balancedBracketScopes',
                         'Defines which scope names contain balanced brackets.'
-                    )),
+                    ))),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -102,10 +102,10 @@ const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
                     default: ['*'],
                 },
                 unbalancedBracketScopes: {
-                    description: ( localize(
+                    description: ( (localize(
                         'vscode.extension.contributes.grammars.unbalancedBracketScopes',
                         'Defines which scope names do not contain balanced brackets.'
-                    )),
+                    ))),
                     type: 'array',
                     items: {
                         type: 'string'
@@ -116,7 +116,7 @@ const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             required: ['scopeName', 'path']
         }
     }
-}));
+})));
 class TMScopeRegistry extends Disposable {
     constructor() {
         super();
@@ -130,8 +130,8 @@ class TMScopeRegistry extends Disposable {
             const existingRegistration = this._scopeNameToLanguageRegistration[def.scopeName];
             if (!isEqual(existingRegistration.location, def.location)) {
                 console.warn(`Overwriting grammar scope name to file mapping for scope ${def.scopeName}.\n` +
-                    `Old grammar file: ${( existingRegistration.location.toString())}.\n` +
-                    `New grammar file: ${( def.location.toString())}`);
+                    `Old grammar file: ${( ( existingRegistration.location.toString()))}.\n` +
+                    `New grammar file: ${( ( def.location.toString()))}`);
             }
         }
         this._scopeNameToLanguageRegistration[def.scopeName] = def;
@@ -146,10 +146,10 @@ class TMGrammarFactory extends Disposable {
         super();
         this._host = host;
         this._initialState = vscodeTextmate.INITIAL;
-        this._scopeRegistry = this._register(( new TMScopeRegistry()));
+        this._scopeRegistry = this._register(( (new TMScopeRegistry())));
         this._injections = {};
         this._injectedEmbeddedLanguages = {};
-        this._languageToScope = ( new Map());
+        this._languageToScope = ( (new Map()));
         this._grammarRegistry = this._register(new vscodeTextmate.Registry({
             onigLib: onigLib,
             loadGrammar: async (scopeName) => {
@@ -225,12 +225,12 @@ class TMGrammarFactory extends Disposable {
         if (this._injectedEmbeddedLanguages[scopeName]) {
             const injectedEmbeddedLanguages = this._injectedEmbeddedLanguages[scopeName];
             for (const injected of injectedEmbeddedLanguages) {
-                for (const scope of ( Object.keys(injected))) {
+                for (const scope of ( (Object.keys(injected)))) {
                     embeddedLanguages[scope] = injected[scope];
                 }
             }
         }
-        const containsEmbeddedLanguages = (( Object.keys(embeddedLanguages)).length > 0);
+        const containsEmbeddedLanguages = (( (Object.keys(embeddedLanguages))).length > 0);
         let grammar;
         try {
             grammar = await this._grammarRegistry.loadGrammarWithConfiguration(scopeName, encodedLanguageId, {
@@ -257,7 +257,7 @@ class TMGrammarFactory extends Disposable {
 class TMTokenization extends Disposable {
     constructor(grammar, initialState, containsEmbeddedLanguages) {
         super();
-        this._onDidEncounterLanguage = this._register(( new Emitter()));
+        this._onDidEncounterLanguage = this._register(( (new Emitter())));
         this.onDidEncounterLanguage = this._onDidEncounterLanguage.event;
         this._grammar = grammar;
         this._initialState = initialState;
@@ -274,7 +274,9 @@ class TMTokenization extends Disposable {
         const textMateResult = this._grammar.tokenizeLine2(line, state, 500);
         if (textMateResult.stoppedEarly) {
             console.warn(`Time limit reached when tokenizing line: ${line.substring(0, 100)}`);
-            return ( new EncodedTokenizationResult(textMateResult.tokens, state));
+            return (
+                 (new EncodedTokenizationResult(textMateResult.tokens, state))
+            );
         }
         if (this._containsEmbeddedLanguages) {
             const seenLanguages = this._seenLanguages;
@@ -295,7 +297,9 @@ class TMTokenization extends Disposable {
         else {
             endState = textMateResult.ruleStack;
         }
-        return ( new EncodedTokenizationResult(textMateResult.tokens, endState));
+        return (
+             (new EncodedTokenizationResult(textMateResult.tokens, endState))
+        );
     }
 }
 let AbstractTextMateService = class AbstractTextMateService extends Disposable {
@@ -308,7 +312,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         this._logService = _logService;
         this._configurationService = _configurationService;
         this._progressService = _progressService;
-        this._onDidEncounterLanguage = this._register(( new Emitter()));
+        this._onDidEncounterLanguage = this._register(( (new Emitter())));
         this.onDidEncounterLanguage = this._onDidEncounterLanguage.event;
         this._vscodeOniguruma = null;
         this._styleElement = createStyleSheet();
@@ -340,7 +344,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
                     const grammarLocation = joinPath(extension.description.extensionLocation, grammar.path);
                     const embeddedLanguages = Object.create(null);
                     if (grammar.embeddedLanguages) {
-                        const scopes = ( Object.keys(grammar.embeddedLanguages));
+                        const scopes = ( (Object.keys(grammar.embeddedLanguages)));
                         for (let i = 0, len = scopes.length; i < len; i++) {
                             const scope = scopes[i];
                             const language = grammar.embeddedLanguages[scope];
@@ -354,7 +358,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
                     }
                     const tokenTypes = Object.create(null);
                     if (grammar.tokenTypes) {
-                        const scopes = ( Object.keys(grammar.tokenTypes));
+                        const scopes = ( (Object.keys(grammar.tokenTypes)));
                         for (const scope of scopes) {
                             const tokenType = grammar.tokenTypes[scope];
                             switch (tokenType) {
@@ -412,7 +416,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
     }
     startDebugMode(printFn, onStop) {
         if (this._debugMode) {
-            this._notificationService.error(( localize('alreadyDebugging', "Already Logging.")));
+            this._notificationService.error(( (localize('alreadyDebugging', "Already Logging."))));
             return;
         }
         this._debugModePrintFunc = printFn;
@@ -420,20 +424,22 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         if (this._debugMode) {
             this._progressService.withProgress({
                 location: 15 ,
-                buttons: [( localize('stop', "Stop"))]
+                buttons: [( (localize('stop', "Stop")))]
             }, (progress) => {
                 progress.report({
-                    message: ( localize(
+                    message: ( (localize(
                         'progress1',
                         "Preparing to log TM Grammar parsing. Press Stop when finished."
-                    ))
+                    )))
                 });
                 return this._getVSCodeOniguruma().then((vscodeOniguruma) => {
                     vscodeOniguruma.setDefaultDebugCall(true);
                     progress.report({
-                        message: ( localize('progress2', "Now logging TM Grammar parsing. Press Stop when finished."))
+                        message: ( (localize('progress2', "Now logging TM Grammar parsing. Press Stop when finished.")))
                     });
-                    return ( new Promise((resolve, reject) => { }));
+                    return (
+                         (new Promise((resolve, reject) => { }))
+                    );
                 });
             }, (choice) => {
                 this._getVSCodeOniguruma().then((vscodeOniguruma) => {
@@ -460,11 +466,11 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         if (this._grammarFactory) {
             return this._grammarFactory;
         }
-        this._grammarFactory = ( new TMGrammarFactory({
+        this._grammarFactory = ( (new TMGrammarFactory({
             logTrace: (msg) => this._logService.trace(msg),
             logError: (msg, err) => this._logService.error(msg, err),
             readFile: (resource) => this._extensionResourceLoaderService.readExtensionResource(resource)
-        }, this._grammarDefinitions || [], vscodeTextmate, onigLib));
+        }, this._grammarDefinitions || [], vscodeTextmate, onigLib)));
         this._onDidCreateGrammarFactory(this._grammarDefinitions || []);
         this._updateTheme(this._grammarFactory, this._themeService.getColorTheme(), true);
         return this._grammarFactory;
@@ -488,7 +494,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
                     if (!r.grammar) {
                         return null;
                     }
-                    const tokenization = ( new TMTokenization(r.grammar, r.initialState, r.containsEmbeddedLanguages));
+                    const tokenization = ( (new TMTokenization(r.grammar, r.initialState, r.containsEmbeddedLanguages)));
                     tokenization.onDidEncounterLanguage((encodedLanguageId) => {
                         if (!this._encounteredLanguages[encodedLanguageId]) {
                             const languageId = this._languageService.languageIdCodec.decodeLanguageId(encodedLanguageId);
@@ -496,7 +502,9 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
                             this._onDidEncounterLanguage.fire(languageId);
                         }
                     });
-                    return ( new TMTokenizationSupportWithLineLimit(languageId, encodedLanguageId, tokenization, this._configurationService));
+                    return (
+                         (new TMTokenizationSupportWithLineLimit(languageId, encodedLanguageId, tokenization, this._configurationService))
+                    );
                 }
                 catch (err) {
                     if (err.message && err.message === missingTMGrammarErrorMessage) {
@@ -511,7 +519,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
     static _toColorMap(colorMap) {
         const result = [null];
         for (let i = 1, len = colorMap.length; i < len; i++) {
-            result[i] = ( Color.fromHex(colorMap[i]));
+            result[i] = ( (Color.fromHex(colorMap[i])));
         }
         return result;
     }
@@ -555,68 +563,68 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
     }
     _validateGrammarExtensionPoint(extensionLocation, syntax, collector) {
         if (syntax.language && ((typeof syntax.language !== 'string') || !this._languageService.isRegisteredLanguageId(syntax.language))) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.language',
                 "Unknown language in `contributes.{0}.language`. Provided value: {1}",
                 grammarsExtPoint.name,
                 String(syntax.language)
-            )));
+            ))));
             return false;
         }
         if (!syntax.scopeName || (typeof syntax.scopeName !== 'string')) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.scopeName',
                 "Expected string in `contributes.{0}.scopeName`. Provided value: {1}",
                 grammarsExtPoint.name,
                 String(syntax.scopeName)
-            )));
+            ))));
             return false;
         }
         if (!syntax.path || (typeof syntax.path !== 'string')) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.path.0',
                 "Expected string in `contributes.{0}.path`. Provided value: {1}",
                 grammarsExtPoint.name,
                 String(syntax.path)
-            )));
+            ))));
             return false;
         }
         if (syntax.injectTo && (!Array.isArray(syntax.injectTo) || syntax.injectTo.some(scope => typeof scope !== 'string'))) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.injectTo',
                 "Invalid value in `contributes.{0}.injectTo`. Must be an array of language scope names. Provided value: {1}",
                 grammarsExtPoint.name,
                 JSON.stringify(syntax.injectTo)
-            )));
+            ))));
             return false;
         }
         if (syntax.embeddedLanguages && !isObject(syntax.embeddedLanguages)) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.embeddedLanguages',
                 "Invalid value in `contributes.{0}.embeddedLanguages`. Must be an object map from scope name to language. Provided value: {1}",
                 grammarsExtPoint.name,
                 JSON.stringify(syntax.embeddedLanguages)
-            )));
+            ))));
             return false;
         }
         if (syntax.tokenTypes && !isObject(syntax.tokenTypes)) {
-            collector.error(( localize(
+            collector.error(( (localize(
                 'invalid.tokenTypes',
                 "Invalid value in `contributes.{0}.tokenTypes`. Must be an object map from scope name to token type. Provided value: {1}",
                 grammarsExtPoint.name,
                 JSON.stringify(syntax.tokenTypes)
-            )));
+            ))));
             return false;
         }
         const grammarLocation = joinPath(extensionLocation, syntax.path);
         if (!isEqualOrParent(grammarLocation, extensionLocation)) {
-            collector.warn(( localize(
+            collector.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.",
                 grammarsExtPoint.name,
                 grammarLocation.path,
                 extensionLocation.path
-            )));
+            ))));
         }
         return true;
     }
@@ -654,15 +662,15 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         return vscodeOniguruma;
     }
 };
-AbstractTextMateService = ( __decorate([
-    ( __param(0, ILanguageService)),
-    ( __param(1, IWorkbenchThemeService)),
-    ( __param(2, IExtensionResourceLoaderService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IProgressService))
-], AbstractTextMateService));
+AbstractTextMateService = ( (__decorate([
+    ( (__param(0, ILanguageService))),
+    ( (__param(1, IWorkbenchThemeService))),
+    ( (__param(2, IExtensionResourceLoaderService))),
+    ( (__param(3, INotificationService))),
+    ( (__param(4, ILogService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IProgressService)))
+], AbstractTextMateService)));
 let TMTokenizationSupportWithLineLimit = class TMTokenizationSupportWithLineLimit {
     constructor(languageId, encodedLanguageId, actual, _configurationService) {
         this._configurationService = _configurationService;
@@ -693,9 +701,9 @@ let TMTokenizationSupportWithLineLimit = class TMTokenizationSupportWithLineLimi
         return this._actual.tokenizeEncoded(line, hasEOL, state);
     }
 };
-TMTokenizationSupportWithLineLimit = ( __decorate([
-    ( __param(3, IConfigurationService))
-], TMTokenizationSupportWithLineLimit));
+TMTokenizationSupportWithLineLimit = ( (__decorate([
+    ( (__param(3, IConfigurationService)))
+], TMTokenizationSupportWithLineLimit)));
 let TextMateService = class TextMateService extends createInjectedClass(AbstractTextMateService) {
     constructor(loadVSCodeOnigurumWASM, instantiationService) {
         super(instantiationService);
@@ -705,9 +713,9 @@ let TextMateService = class TextMateService extends createInjectedClass(Abstract
         return this.loadVSCodeOnigurumWASM();
     }
 };
-TextMateService = __decorate([
-    __param(1, IInstantiationService)
-], TextMateService);
+TextMateService = ( __decorate([
+    ( __param(1, IInstantiationService))
+], TextMateService));
 const extensionPoint = getExtensionPoint('grammars');
 function setGrammars(grammars, getContent, extension = Services.get().extension ?? DEFAULT_EXTENSION) {
     extensionPoint.acceptUsers([{
@@ -726,7 +734,7 @@ function getServiceOverride(getOnigLib) {
     onServicesInitialized(initialize);
     return {
         ...getServiceOverride$1(),
-        [ITextMateService.toString()]: new SyncDescriptor(TextMateService, [getOnigLib])
+        [( ITextMateService.toString())]: new SyncDescriptor(TextMateService, [getOnigLib])
     };
 }
 export { getServiceOverride as default, setGrammars };