@codingame/monaco-vscode-editor-api 25.1.2 → 26.0.0

package/vscode/src/vs/editor/standalone/common/monarch/monarchLexer.js

@@ -10,7 +10,9 @@ import { LanguageId, MetadataConsts } from '@codingame/monaco-vscode-api/vscode/
 var MonarchTokenizer_1;
 const CACHE_STACK_DEPTH = 5;
 class MonarchStackElementFactory {
-    static { this._INSTANCE = ( new MonarchStackElementFactory(CACHE_STACK_DEPTH)); }
+    static {
+        this._INSTANCE = ( new MonarchStackElementFactory(CACHE_STACK_DEPTH));
+    }
     static create(parent, state) {
         return this._INSTANCE.create(parent, state);
     }
@@ -24,7 +26,7 @@ class MonarchStackElementFactory {
         }
         let stackElementId = MonarchStackElement.getStackElementId(parent);
         if (stackElementId.length > 0) {
-            stackElementId += '|';
+            stackElementId += "|";
         }
         stackElementId += state;
         let result = this._entries[stackElementId];
@@ -43,10 +45,10 @@ class MonarchStackElement {
         this.depth = (this.parent ? this.parent.depth : 0) + 1;
     }
     static getStackElementId(element) {
-        let result = '';
+        let result = "";
         while (element !== null) {
             if (result.length > 0) {
-                result += '|';
+                result += "|";
             }
             result += element.state;
             element = element.parent;
@@ -95,8 +97,7 @@ class EmbeddedLanguageData {
         this.state = state;
     }
     equals(other) {
-        return (this.languageId === other.languageId
-            && this.state.equals(other.state));
+        return (this.languageId === other.languageId && this.state.equals(other.state));
     }
     clone() {
         const stateClone = this.state.clone();
@@ -107,7 +108,9 @@ class EmbeddedLanguageData {
     }
 }
 class MonarchLineStateFactory {
-    static { this._INSTANCE = ( new MonarchLineStateFactory(CACHE_STACK_DEPTH)); }
+    static {
+        this._INSTANCE = ( new MonarchLineStateFactory(CACHE_STACK_DEPTH));
+    }
     static create(stack, embeddedLanguageData) {
         return this._INSTANCE.create(stack, embeddedLanguageData);
     }
@@ -184,16 +187,17 @@ class MonarchClassicTokensCollector {
         const nestedLanguageTokenizationSupport = TokenizationRegistry.get(nestedLanguageId);
         if (!nestedLanguageTokenizationSupport) {
             this.enterLanguage(nestedLanguageId);
-            this.emit(offsetDelta, '');
+            this.emit(offsetDelta, "");
             return embeddedModeState;
         }
         const nestedResult = nestedLanguageTokenizationSupport.tokenize(embeddedLanguageLine, hasEOL, embeddedModeState);
         if (offsetDelta !== 0) {
             for (const token of nestedResult.tokens) {
-                this._tokens.push(new Token(token.offset + offsetDelta, token.type, token.language));
+                this._tokens.push(
+                    new Token(token.offset + offsetDelta, token.type, token.language)
+                );
             }
-        }
-        else {
+        } else {
             this._tokens = this._tokens.concat(nestedResult.tokens);
         }
         this._lastTokenType = null;
@@ -257,7 +261,7 @@ class MonarchModernTokensCollector {
         const nestedLanguageTokenizationSupport = TokenizationRegistry.get(nestedLanguageId);
         if (!nestedLanguageTokenizationSupport) {
             this.enterLanguage(nestedLanguageId);
-            this.emit(offsetDelta, '');
+            this.emit(offsetDelta, "");
             return embeddedModeState;
         }
         const nestedResult = nestedLanguageTokenizationSupport.tokenizeEncoded(embeddedLanguageLine, hasEOL, embeddedModeState);
@@ -273,11 +277,21 @@ class MonarchModernTokensCollector {
         return nestedResult.endState;
     }
     finalize(endState) {
-        return new EncodedTokenizationResult(MonarchModernTokensCollector._merge(this._prependTokens, this._tokens, null), [], endState);
+        return new EncodedTokenizationResult(
+            MonarchModernTokensCollector._merge(this._prependTokens, this._tokens, null),
+            [],
+            endState
+        );
     }
 }
 let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Disposable {
-    constructor(languageService, standaloneThemeService, languageId, lexer, _configurationService) {
+    constructor(
+        languageService,
+        standaloneThemeService,
+        languageId,
+        lexer,
+        _configurationService
+    ) {
         super();
         this._configurationService = _configurationService;
         this._languageService = languageService;
@@ -287,7 +301,7 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
         this._embeddedLanguages = Object.create(null);
         this.embeddedLoaded = Promise.resolve(undefined);
         let emitting = false;
-        this._register(TokenizationRegistry.onDidChange((e) => {
+        this._register(TokenizationRegistry.onDidChange(e => {
             if (emitting) {
                 return;
             }
@@ -305,12 +319,12 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 emitting = false;
             }
         }));
-        this._maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
+        this._maxTokenizationLineLength = this._configurationService.getValue("editor.maxTokenizationLineLength", {
             overrideIdentifier: this._languageId
         });
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor.maxTokenizationLineLength')) {
-                this._maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
+            if (e.affectsConfiguration("editor.maxTokenizationLineLength")) {
+                this._maxTokenizationLineLength = this._configurationService.getValue("editor.maxTokenizationLineLength", {
                     overrideIdentifier: this._languageId
                 });
             }
@@ -357,7 +371,10 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
     }
     tokenizeEncoded(line, hasEOL, lineState) {
         if (line.length >= this._maxTokenizationLineLength) {
-            return nullTokenizeEncoded(this._languageService.languageIdCodec.encodeLanguageId(this._languageId), lineState);
+            return nullTokenizeEncoded(
+                this._languageService.languageIdCodec.encodeLanguageId(this._languageId),
+                lineState
+            );
         }
         const tokensCollector = ( new MonarchModernTokensCollector(
             this._languageService,
@@ -369,8 +386,7 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
     _tokenize(line, hasEOL, lineState, collector) {
         if (lineState.embeddedLanguageData) {
             return this._nestedTokenize(line, hasEOL, lineState, 0, collector);
-        }
-        else {
+        } else {
             return this._myTokenize(line, hasEOL, lineState, 0, collector);
         }
     }
@@ -379,20 +395,20 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
         if (!rules) {
             rules = findRules(this._lexer, state.stack.state);
             if (!rules) {
-                throw createError(this._lexer, 'tokenizer state is not defined: ' + state.stack.state);
+                throw createError(this._lexer, "tokenizer state is not defined: " + state.stack.state);
             }
         }
         let popOffset = -1;
         let hasEmbeddedPopRule = false;
         for (const rule of rules) {
-            if (!isIAction(rule.action) || !(rule.action.nextEmbedded === '@pop' || rule.action.hasEmbeddedEndInCases)) {
+            if (!isIAction(rule.action) || !(rule.action.nextEmbedded === "@pop" || rule.action.hasEmbeddedEndInCases)) {
                 continue;
             }
             hasEmbeddedPopRule = true;
             let regex = rule.resolveRegex(state.stack.state);
             const regexSource = regex.source;
-            if (regexSource.substr(0, 4) === '^(?:' && regexSource.substr(regexSource.length - 1, 1) === ')') {
-                const flags = (regex.ignoreCase ? 'i' : '') + (regex.unicode ? 'u' : '');
+            if (regexSource.substr(0, 4) === "^(?:" && regexSource.substr(regexSource.length - 1, 1) === ")") {
+                const flags = (regex.ignoreCase ? "i" : "") + (regex.unicode ? "u" : "");
                 regex = ( new RegExp(regexSource.substr(4, regexSource.length - 5), flags));
             }
             const result = line.search(regex);
@@ -404,7 +420,10 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
             }
         }
         if (!hasEmbeddedPopRule) {
-            throw createError(this._lexer, 'no rule containing nextEmbedded: "@pop" in tokenizer embedded state: ' + state.stack.state);
+            throw createError(
+                this._lexer,
+                "no rule containing nextEmbedded: \"@pop\" in tokenizer embedded state: " + state.stack.state
+            );
         }
         return popOffset;
     }
@@ -425,12 +444,12 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
         if (rule) {
             return rule.name;
         }
-        return '(unknown)';
+        return "(unknown)";
     }
     _myTokenize(lineWithoutLF, hasEOL, lineState, offsetDelta, tokensCollector) {
         tokensCollector.enterLanguage(this._languageId);
         const lineWithoutLFLength = lineWithoutLF.length;
-        const line = (hasEOL && this._lexer.includeLF ? lineWithoutLF + '\n' : lineWithoutLF);
+        const line = (hasEOL && this._lexer.includeLF ? lineWithoutLF + "\n" : lineWithoutLF);
         const lineLength = line.length;
         let embeddedLanguageData = lineState.embeddedLanguageData;
         let stack = lineState.stack;
@@ -456,8 +475,7 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 if (groupMatching.groups.length === 0) {
                     groupMatching = null;
                 }
-            }
-            else {
+            } else {
                 if (!forceEvaluation && pos >= lineLength) {
                     break;
                 }
@@ -466,7 +484,7 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 if (!rules) {
                     rules = findRules(this._lexer, state);
                     if (!rules) {
-                        throw createError(this._lexer, 'tokenizer state is not defined: ' + state);
+                        throw createError(this._lexer, "tokenizer state is not defined: " + state);
                     }
                 }
                 const restOfLine = line.substr(pos);
@@ -482,8 +500,8 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 }
             }
             if (!matches) {
-                matches = [''];
-                matched = '';
+                matches = [""];
+                matched = "";
             }
             if (!action) {
                 if (pos < lineLength) {
@@ -500,118 +518,133 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 action = action.test(matched, matches, state, pos === lineLength);
             }
             let result = null;
-            if (typeof action === 'string' || Array.isArray(action)) {
+            if (typeof action === "string" || Array.isArray(action)) {
                 result = action;
-            }
-            else if (action.group) {
+            } else if (action.group) {
                 result = action.group;
-            }
-            else if (action.token !== null && action.token !== undefined) {
+            } else if (action.token !== null && action.token !== undefined) {
                 if (action.tokenSubst) {
                     result = substituteMatches(this._lexer, action.token, matched, matches, state);
-                }
-                else {
+                } else {
                     result = action.token;
                 }
                 if (action.nextEmbedded) {
-                    if (action.nextEmbedded === '@pop') {
+                    if (action.nextEmbedded === "@pop") {
                         if (!embeddedLanguageData) {
-                            throw createError(this._lexer, 'cannot pop embedded language if not inside one');
+                            throw createError(this._lexer, "cannot pop embedded language if not inside one");
                         }
                         embeddedLanguageData = null;
-                    }
-                    else if (embeddedLanguageData) {
-                        throw createError(this._lexer, 'cannot enter embedded language from within an embedded language');
-                    }
-                    else {
+                    } else if (embeddedLanguageData) {
+                        throw createError(
+                            this._lexer,
+                            "cannot enter embedded language from within an embedded language"
+                        );
+                    } else {
                         enteringEmbeddedLanguage = substituteMatches(this._lexer, action.nextEmbedded, matched, matches, state);
                     }
                 }
                 if (action.goBack) {
                     pos = Math.max(0, pos - action.goBack);
                 }
-                if (action.switchTo && typeof action.switchTo === 'string') {
+                if (action.switchTo && typeof action.switchTo === "string") {
                     let nextState = substituteMatches(this._lexer, action.switchTo, matched, matches, state);
-                    if (nextState[0] === '@') {
+                    if (nextState[0] === "@") {
                         nextState = nextState.substr(1);
                     }
                     if (!findRules(this._lexer, nextState)) {
-                        throw createError(this._lexer, 'trying to switch to a state \'' + nextState + '\' that is undefined in rule: ' + this._safeRuleName(rule));
-                    }
-                    else {
+                        throw createError(
+                            this._lexer,
+                            "trying to switch to a state '" + nextState + "' that is undefined in rule: " + this._safeRuleName(rule)
+                        );
+                    } else {
                         stack = stack.switchTo(nextState);
                     }
-                }
-                else if (action.transform && typeof action.transform === 'function') {
-                    throw createError(this._lexer, 'action.transform not supported');
-                }
-                else if (action.next) {
-                    if (action.next === '@push') {
+                } else if (action.transform && typeof action.transform === "function") {
+                    throw createError(this._lexer, "action.transform not supported");
+                } else if (action.next) {
+                    if (action.next === "@push") {
                         if (stack.depth >= this._lexer.maxStack) {
-                            throw createError(this._lexer, 'maximum tokenizer stack size reached: [' +
-                                stack.state + ',' + stack.parent.state + ',...]');
-                        }
-                        else {
+                            throw createError(
+                                this._lexer,
+                                "maximum tokenizer stack size reached: [" + stack.state + "," + stack.parent.state + ",...]"
+                            );
+                        } else {
                             stack = stack.push(state);
                         }
-                    }
-                    else if (action.next === '@pop') {
+                    } else if (action.next === "@pop") {
                         if (stack.depth <= 1) {
-                            throw createError(this._lexer, 'trying to pop an empty stack in rule: ' + this._safeRuleName(rule));
-                        }
-                        else {
+                            throw createError(
+                                this._lexer,
+                                "trying to pop an empty stack in rule: " + this._safeRuleName(rule)
+                            );
+                        } else {
                             stack = stack.pop();
                         }
-                    }
-                    else if (action.next === '@popall') {
+                    } else if (action.next === "@popall") {
                         stack = stack.popall();
-                    }
-                    else {
+                    } else {
                         let nextState = substituteMatches(this._lexer, action.next, matched, matches, state);
-                        if (nextState[0] === '@') {
+                        if (nextState[0] === "@") {
                             nextState = nextState.substr(1);
                         }
                         if (!findRules(this._lexer, nextState)) {
-                            throw createError(this._lexer, 'trying to set a next state \'' + nextState + '\' that is undefined in rule: ' + this._safeRuleName(rule));
-                        }
-                        else {
+                            throw createError(
+                                this._lexer,
+                                "trying to set a next state '" + nextState + "' that is undefined in rule: " + this._safeRuleName(rule)
+                            );
+                        } else {
                             stack = stack.push(nextState);
                         }
                     }
                 }
-                if (action.log && typeof (action.log) === 'string') {
-                    log(this._lexer, this._lexer.languageId + ': ' + substituteMatches(this._lexer, action.log, matched, matches, state));
+                if (action.log && typeof (action.log) === "string") {
+                    log(
+                        this._lexer,
+                        this._lexer.languageId + ": " + substituteMatches(this._lexer, action.log, matched, matches, state)
+                    );
                 }
             }
             if (result === null) {
-                throw createError(this._lexer, 'lexer rule has no well-defined action in rule: ' + this._safeRuleName(rule));
+                throw createError(
+                    this._lexer,
+                    "lexer rule has no well-defined action in rule: " + this._safeRuleName(rule)
+                );
             }
-            const computeNewStateForEmbeddedLanguage = (enteringEmbeddedLanguage) => {
-                const languageId = (this._languageService.getLanguageIdByLanguageName(enteringEmbeddedLanguage)
-                    || this._languageService.getLanguageIdByMimeType(enteringEmbeddedLanguage)
-                    || enteringEmbeddedLanguage);
+            const computeNewStateForEmbeddedLanguage = enteringEmbeddedLanguage => {
+                const languageId = (this._languageService.getLanguageIdByLanguageName(enteringEmbeddedLanguage) || this._languageService.getLanguageIdByMimeType(enteringEmbeddedLanguage) || enteringEmbeddedLanguage);
                 const embeddedLanguageData = this._getNestedEmbeddedLanguageData(languageId);
                 if (pos < lineLength) {
                     const restOfLine = lineWithoutLF.substr(pos);
-                    return this._nestedTokenize(restOfLine, hasEOL, MonarchLineStateFactory.create(stack, embeddedLanguageData), offsetDelta + pos, tokensCollector);
-                }
-                else {
+                    return this._nestedTokenize(
+                        restOfLine,
+                        hasEOL,
+                        MonarchLineStateFactory.create(stack, embeddedLanguageData),
+                        offsetDelta + pos,
+                        tokensCollector
+                    );
+                } else {
                     return MonarchLineStateFactory.create(stack, embeddedLanguageData);
                 }
             };
             if (Array.isArray(result)) {
                 if (groupMatching && groupMatching.groups.length > 0) {
-                    throw createError(this._lexer, 'groups cannot be nested: ' + this._safeRuleName(rule));
+                    throw createError(this._lexer, "groups cannot be nested: " + this._safeRuleName(rule));
                 }
                 if (matches.length !== result.length + 1) {
-                    throw createError(this._lexer, 'matched number of groups does not match the number of actions in rule: ' + this._safeRuleName(rule));
+                    throw createError(
+                        this._lexer,
+                        "matched number of groups does not match the number of actions in rule: " + this._safeRuleName(rule)
+                    );
                 }
                 let totalLen = 0;
                 for (let i = 1; i < matches.length; i++) {
                     totalLen += matches[i].length;
                 }
                 if (totalLen !== matched.length) {
-                    throw createError(this._lexer, 'with groups, all characters should be matched in consecutive groups in rule: ' + this._safeRuleName(rule));
+                    throw createError(
+                        this._lexer,
+                        "with groups, all characters should be matched in consecutive groups in rule: " + this._safeRuleName(rule)
+                    );
                 }
                 groupMatching = {
                     rule: rule,
@@ -626,13 +659,12 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 }
                 pos -= matched.length;
                 continue;
-            }
-            else {
-                if (result === '@rematch') {
+            } else {
+                if (result === "@rematch") {
                     pos -= matched.length;
-                    matched = '';
+                    matched = "";
                     matches = null;
-                    result = '';
+                    result = "";
                     if (enteringEmbeddedLanguage !== null) {
                         return computeNewStateForEmbeddedLanguage(enteringEmbeddedLanguage);
                     }
@@ -640,22 +672,26 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
                 if (matched.length === 0) {
                     if (lineLength === 0 || stackLen0 !== stack.depth || state !== stack.state || (!groupMatching ? 0 : groupMatching.groups.length) !== groupLen0) {
                         continue;
-                    }
-                    else {
-                        throw createError(this._lexer, 'no progress in tokenizer in rule: ' + this._safeRuleName(rule));
+                    } else {
+                        throw createError(
+                            this._lexer,
+                            "no progress in tokenizer in rule: " + this._safeRuleName(rule)
+                        );
                     }
                 }
                 let tokenType = null;
-                if (isString(result) && result.indexOf('@brackets') === 0) {
-                    const rest = result.substr('@brackets'.length);
+                if (isString(result) && result.indexOf("@brackets") === 0) {
+                    const rest = result.substr("@brackets".length);
                     const bracket = findBracket(this._lexer, matched);
                     if (!bracket) {
-                        throw createError(this._lexer, '@brackets token returned but no bracket defined as: ' + matched);
+                        throw createError(
+                            this._lexer,
+                            "@brackets token returned but no bracket defined as: " + matched
+                        );
                     }
                     tokenType = sanitize(bracket.token + rest);
-                }
-                else {
-                    const token = (result === '' ? '' : result + this._lexer.tokenPostfix);
+                } else {
+                    const token = (result === "" ? "" : result + this._lexer.tokenPostfix);
                     tokenType = sanitize(token);
                 }
                 if (pos0 < lineWithoutLFLength) {
@@ -684,9 +720,7 @@ let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Dispo
         return ( new EmbeddedLanguageData(languageId, NullState));
     }
 };
-MonarchTokenizer = MonarchTokenizer_1 = ( __decorate([
-    ( __param(4, IConfigurationService))
-], MonarchTokenizer));
+MonarchTokenizer = MonarchTokenizer_1 = ( __decorate([( __param(4, IConfigurationService))], MonarchTokenizer));
 function findBracket(lexer, matched) {
     if (!matched) {
         return null;
@@ -695,10 +729,15 @@ function findBracket(lexer, matched) {
     const brackets = lexer.brackets;
     for (const bracket of brackets) {
         if (bracket.open === matched) {
-            return { token: bracket.token, bracketType: MonarchBracket.Open };
-        }
-        else if (bracket.close === matched) {
-            return { token: bracket.token, bracketType: MonarchBracket.Close };
+            return {
+                token: bracket.token,
+                bracketType: MonarchBracket.Open
+            };
+        } else if (bracket.close === matched) {
+            return {
+                token: bracket.token,
+                bracketType: MonarchBracket.Close
+            };
         }
     }
     return null;