@codingame/monaco-vscode-api 4.5.0-improve-code-splitting.1 → 4.5.1

package/vscode/src/vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens.js

@@ -1,503 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './inspectEditorTokens.css.js';
-import { localizeWithPath } from '../../../../../nls.js';
-import { clearNode, reset, append, $ as $$1 } from '../../../../../base/browser/dom.js';
-import { Color } from '../../../../../base/common/color.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { registerEditorContribution, registerEditorAction, EditorAction } from '../../../../../editor/browser/editorExtensions.js';
-import { Range } from '../../../../../editor/common/core/range.js';
-import { TokenMetadata } from '../../../../../editor/common/encodedTokenAttributes.js';
-import { ILanguageService } from '../../../../../editor/common/languages/language.js';
-import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
-import { findMatchingThemeRule } from '../../../../services/textMate/common/TMHelper.js';
-import { ITextMateTokenizationService } from '../../../../services/textMate/browser/textMateTokenizationFeature.service.js';
-import { IWorkbenchThemeService } from '../../../../services/themes/common/workbenchThemeService.service.js';
-import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
-import { SemanticTokenRule } from '../../../../../platform/theme/common/tokenClassificationRegistry.js';
-import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
-import { SEMANTIC_HIGHLIGHTING_SETTING_ID } from '../../../../../editor/contrib/semanticTokens/common/semanticTokensConfig.js';
-import { Schemas } from '../../../../../base/common/network.js';
-import { ILanguageFeaturesService } from '../../../../../editor/common/services/languageFeatures.js';
-var InspectEditorTokensController_1;
-const $ = $$1;
-let InspectEditorTokensController = class InspectEditorTokensController extends Disposable {
-    static { InspectEditorTokensController_1 = this; }
-    static { this.ID = 'editor.contrib.inspectEditorTokens'; }
-    static get(editor) {
-        return editor.getContribution(InspectEditorTokensController_1.ID);
-    }
-    constructor(editor, textMateService, languageService, themeService, notificationService, configurationService, languageFeaturesService) {
-        super();
-        this._editor = editor;
-        this._textMateService = textMateService;
-        this._themeService = themeService;
-        this._languageService = languageService;
-        this._notificationService = notificationService;
-        this._configurationService = configurationService;
-        this._languageFeaturesService = languageFeaturesService;
-        this._widget = null;
-        this._register(this._editor.onDidChangeModel((e) => this.stop()));
-        this._register(this._editor.onDidChangeModelLanguage((e) => this.stop()));
-        this._register(this._editor.onKeyUp((e) => e.keyCode === 9  && this.stop()));
-    }
-    dispose() {
-        this.stop();
-        super.dispose();
-    }
-    launch() {
-        if (this._widget) {
-            return;
-        }
-        if (!this._editor.hasModel()) {
-            return;
-        }
-        if (this._editor.getModel().uri.scheme === Schemas.vscodeNotebookCell) {
-            return;
-        }
-        this._widget = ( new InspectEditorTokensWidget(
-            this._editor,
-            this._textMateService,
-            this._languageService,
-            this._themeService,
-            this._notificationService,
-            this._configurationService,
-            this._languageFeaturesService
-        ));
-    }
-    stop() {
-        if (this._widget) {
-            this._widget.dispose();
-            this._widget = null;
-        }
-    }
-    toggle() {
-        if (!this._widget) {
-            this.launch();
-        }
-        else {
-            this.stop();
-        }
-    }
-};
-InspectEditorTokensController = InspectEditorTokensController_1 = ( __decorate([
-    ( __param(1, ITextMateTokenizationService)),
-    ( __param(2, ILanguageService)),
-    ( __param(3, IWorkbenchThemeService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, ILanguageFeaturesService))
-], InspectEditorTokensController));
-class InspectEditorTokens extends EditorAction {
-    constructor() {
-        super({
-            id: 'editor.action.inspectTMScopes',
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens',
-                'inspectEditorTokens',
-                "Developer: Inspect Editor Tokens and Scopes"
-            )),
-            alias: 'Developer: Inspect Editor Tokens and Scopes',
-            precondition: undefined
-        });
-    }
-    run(accessor, editor) {
-        const controller = InspectEditorTokensController.get(editor);
-        controller?.toggle();
-    }
-}
-function renderTokenText(tokenText) {
-    if (tokenText.length > 40) {
-        tokenText = tokenText.substr(0, 20) + '…' + tokenText.substr(tokenText.length - 20);
-    }
-    let result = '';
-    for (let charIndex = 0, len = tokenText.length; charIndex < len; charIndex++) {
-        const charCode = tokenText.charCodeAt(charIndex);
-        switch (charCode) {
-            case 9 :
-                result += '\u2192';
-                break;
-            case 32 :
-                result += '\u00B7';
-                break;
-            default:
-                result += String.fromCharCode(charCode);
-        }
-    }
-    return result;
-}
-class InspectEditorTokensWidget extends Disposable {
-    static { this._ID = 'editor.contrib.inspectEditorTokensWidget'; }
-    constructor(editor, textMateService, languageService, themeService, notificationService, configurationService, languageFeaturesService) {
-        super();
-        this.allowEditorOverflow = true;
-        this._isDisposed = false;
-        this._editor = editor;
-        this._languageService = languageService;
-        this._themeService = themeService;
-        this._textMateService = textMateService;
-        this._notificationService = notificationService;
-        this._configurationService = configurationService;
-        this._languageFeaturesService = languageFeaturesService;
-        this._model = this._editor.getModel();
-        this._domNode = document.createElement('div');
-        this._domNode.className = 'token-inspect-widget';
-        this._currentRequestCancellationTokenSource = ( new CancellationTokenSource());
-        this._beginCompute(this._editor.getPosition());
-        this._register(this._editor.onDidChangeCursorPosition((e) => this._beginCompute(this._editor.getPosition())));
-        this._register(themeService.onDidColorThemeChange(_ => this._beginCompute(this._editor.getPosition())));
-        this._register(configurationService.onDidChangeConfiguration(e => e.affectsConfiguration('editor.semanticHighlighting.enabled') && this._beginCompute(this._editor.getPosition())));
-        this._editor.addContentWidget(this);
-    }
-    dispose() {
-        this._isDisposed = true;
-        this._editor.removeContentWidget(this);
-        this._currentRequestCancellationTokenSource.cancel();
-        super.dispose();
-    }
-    getId() {
-        return InspectEditorTokensWidget._ID;
-    }
-    _beginCompute(position) {
-        const grammar = this._textMateService.createTokenizer(this._model.getLanguageId());
-        const semanticTokens = this._computeSemanticTokens(position);
-        clearNode(this._domNode);
-        this._domNode.appendChild(document.createTextNode(( localizeWithPath(
-            'vs/workbench/contrib/codeEditor/browser/inspectEditorTokens/inspectEditorTokens',
-            'inspectTMScopesWidget.loading',
-            "Loading..."
-        ))));
-        Promise.all([grammar, semanticTokens]).then(([grammar, semanticTokens]) => {
-            if (this._isDisposed) {
-                return;
-            }
-            this._compute(grammar, semanticTokens, position);
-            this._domNode.style.maxWidth = `${Math.max(this._editor.getLayoutInfo().width * 0.66, 500)}px`;
-            this._editor.layoutContentWidget(this);
-        }, (err) => {
-            this._notificationService.warn(err);
-            setTimeout(() => {
-                InspectEditorTokensController.get(this._editor)?.stop();
-            });
-        });
-    }
-    _isSemanticColoringEnabled() {
-        const setting = this._configurationService.getValue(SEMANTIC_HIGHLIGHTING_SETTING_ID, { overrideIdentifier: this._model.getLanguageId(), resource: this._model.uri })?.enabled;
-        if (typeof setting === 'boolean') {
-            return setting;
-        }
-        return this._themeService.getColorTheme().semanticHighlighting;
-    }
-    _compute(grammar, semanticTokens, position) {
-        const textMateTokenInfo = grammar && this._getTokensAtPosition(grammar, position);
-        const semanticTokenInfo = semanticTokens && this._getSemanticTokenAtPosition(semanticTokens, position);
-        if (!textMateTokenInfo && !semanticTokenInfo) {
-            reset(this._domNode, 'No grammar or semantic tokens available.');
-            return;
-        }
-        const tmMetadata = textMateTokenInfo?.metadata;
-        const semMetadata = semanticTokenInfo?.metadata;
-        const semTokenText = semanticTokenInfo && renderTokenText(this._model.getValueInRange(semanticTokenInfo.range));
-        const tmTokenText = textMateTokenInfo && renderTokenText(this._model.getLineContent(position.lineNumber).substring(textMateTokenInfo.token.startIndex, textMateTokenInfo.token.endIndex));
-        const tokenText = semTokenText || tmTokenText || '';
-        reset(this._domNode, $('h2.tiw-token', undefined, tokenText, $('span.tiw-token-length', undefined, `${tokenText.length} ${tokenText.length === 1 ? 'char' : 'chars'}`)));
-        append(this._domNode, $('hr.tiw-metadata-separator', { 'style': 'clear:both' }));
-        append(this._domNode, $('table.tiw-metadata-table', undefined, $('tbody', undefined, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'language'), $('td.tiw-metadata-value', undefined, tmMetadata?.languageId || '')), $('tr', undefined, $('td.tiw-metadata-key', undefined, 'standard token type'), $('td.tiw-metadata-value', undefined, this._tokenTypeToString(tmMetadata?.tokenType || 0 ))), ...this._formatMetadata(semMetadata, tmMetadata))));
-        if (semanticTokenInfo) {
-            append(this._domNode, $('hr.tiw-metadata-separator'));
-            const table = append(this._domNode, $('table.tiw-metadata-table', undefined));
-            const tbody = append(table, $('tbody', undefined, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'semantic token type'), $('td.tiw-metadata-value', undefined, semanticTokenInfo.type))));
-            if (semanticTokenInfo.modifiers.length) {
-                append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'modifiers'), $('td.tiw-metadata-value', undefined, semanticTokenInfo.modifiers.join(' '))));
-            }
-            if (semanticTokenInfo.metadata) {
-                const properties = ['foreground', 'bold', 'italic', 'underline', 'strikethrough'];
-                const propertiesByDefValue = {};
-                const allDefValues = ( new Array());
-                for (const property of properties) {
-                    if (semanticTokenInfo.metadata[property] !== undefined) {
-                        const definition = semanticTokenInfo.definitions[property];
-                        const defValue = this._renderTokenStyleDefinition(definition, property);
-                        const defValueStr = ( defValue.map(el => el instanceof HTMLElement ? el.outerHTML : el)).join();
-                        let properties = propertiesByDefValue[defValueStr];
-                        if (!properties) {
-                            propertiesByDefValue[defValueStr] = properties = [];
-                            allDefValues.push([defValue, defValueStr]);
-                        }
-                        properties.push(property);
-                    }
-                }
-                for (const [defValue, defValueStr] of allDefValues) {
-                    append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, propertiesByDefValue[defValueStr].join(', ')), $('td.tiw-metadata-value', undefined, ...defValue)));
-                }
-            }
-        }
-        if (textMateTokenInfo) {
-            const theme = this._themeService.getColorTheme();
-            append(this._domNode, $('hr.tiw-metadata-separator'));
-            const table = append(this._domNode, $('table.tiw-metadata-table'));
-            const tbody = append(table, $('tbody'));
-            if (tmTokenText && tmTokenText !== tokenText) {
-                append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'textmate token'), $('td.tiw-metadata-value', undefined, `${tmTokenText} (${tmTokenText.length})`)));
-            }
-            const scopes = ( new Array());
-            for (let i = textMateTokenInfo.token.scopes.length - 1; i >= 0; i--) {
-                scopes.push(textMateTokenInfo.token.scopes[i]);
-                if (i > 0) {
-                    scopes.push($('br'));
-                }
-            }
-            append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'textmate scopes'), $('td.tiw-metadata-value.tiw-metadata-scopes', undefined, ...scopes)));
-            const matchingRule = findMatchingThemeRule(theme, textMateTokenInfo.token.scopes, false);
-            const semForeground = semanticTokenInfo?.metadata?.foreground;
-            if (matchingRule) {
-                if (semForeground !== textMateTokenInfo.metadata.foreground) {
-                    let defValue = $('code.tiw-theme-selector', undefined, matchingRule.rawSelector, $('br'), JSON.stringify(matchingRule.settings, null, '\t'));
-                    if (semForeground) {
-                        defValue = $('s', undefined, defValue);
-                    }
-                    append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'foreground'), $('td.tiw-metadata-value', undefined, defValue)));
-                }
-            }
-            else if (!semForeground) {
-                append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'foreground'), $('td.tiw-metadata-value', undefined, 'No theme selector')));
-            }
-        }
-    }
-    _formatMetadata(semantic, tm) {
-        const elements = ( new Array());
-        function render(property) {
-            const value = semantic?.[property] || tm?.[property];
-            if (value !== undefined) {
-                const semanticStyle = semantic?.[property] ? 'tiw-metadata-semantic' : '';
-                elements.push($('tr', undefined, $('td.tiw-metadata-key', undefined, property), $(`td.tiw-metadata-value.${semanticStyle}`, undefined, value)));
-            }
-            return value;
-        }
-        const foreground = render('foreground');
-        const background = render('background');
-        if (foreground && background) {
-            const backgroundColor = ( Color.fromHex(background)), foregroundColor = ( Color.fromHex(foreground));
-            if (backgroundColor.isOpaque()) {
-                elements.push($('tr', undefined, $('td.tiw-metadata-key', undefined, 'contrast ratio'), $('td.tiw-metadata-value', undefined, backgroundColor.getContrastRatio(foregroundColor.makeOpaque(backgroundColor)).toFixed(2))));
-            }
-            else {
-                elements.push($('tr', undefined, $('td.tiw-metadata-key', undefined, 'Contrast ratio cannot be precise for background colors that use transparency'), $('td.tiw-metadata-value')));
-            }
-        }
-        const fontStyleLabels = ( new Array());
-        function addStyle(key) {
-            let label;
-            if (semantic && semantic[key]) {
-                label = $('span.tiw-metadata-semantic', undefined, key);
-            }
-            else if (tm && tm[key]) {
-                label = key;
-            }
-            if (label) {
-                if (fontStyleLabels.length) {
-                    fontStyleLabels.push(' ');
-                }
-                fontStyleLabels.push(label);
-            }
-        }
-        addStyle('bold');
-        addStyle('italic');
-        addStyle('underline');
-        addStyle('strikethrough');
-        if (fontStyleLabels.length) {
-            elements.push($('tr', undefined, $('td.tiw-metadata-key', undefined, 'font style'), $('td.tiw-metadata-value', undefined, ...fontStyleLabels)));
-        }
-        return elements;
-    }
-    _decodeMetadata(metadata) {
-        const colorMap = this._themeService.getColorTheme().tokenColorMap;
-        const languageId = TokenMetadata.getLanguageId(metadata);
-        const tokenType = TokenMetadata.getTokenType(metadata);
-        const fontStyle = TokenMetadata.getFontStyle(metadata);
-        const foreground = TokenMetadata.getForeground(metadata);
-        const background = TokenMetadata.getBackground(metadata);
-        return {
-            languageId: this._languageService.languageIdCodec.decodeLanguageId(languageId),
-            tokenType: tokenType,
-            bold: ((fontStyle & 2) ) ? true : undefined,
-            italic: ((fontStyle & 1) ) ? true : undefined,
-            underline: ((fontStyle & 4) ) ? true : undefined,
-            strikethrough: ((fontStyle & 8) ) ? true : undefined,
-            foreground: colorMap[foreground],
-            background: colorMap[background]
-        };
-    }
-    _tokenTypeToString(tokenType) {
-        switch (tokenType) {
-            case 0 : return 'Other';
-            case 1 : return 'Comment';
-            case 2 : return 'String';
-            case 3 : return 'RegEx';
-            default: return '??';
-        }
-    }
-    _getTokensAtPosition(grammar, position) {
-        const lineNumber = position.lineNumber;
-        const stateBeforeLine = this._getStateBeforeLine(grammar, lineNumber);
-        const tokenizationResult1 = grammar.tokenizeLine(this._model.getLineContent(lineNumber), stateBeforeLine);
-        const tokenizationResult2 = grammar.tokenizeLine2(this._model.getLineContent(lineNumber), stateBeforeLine);
-        let token1Index = 0;
-        for (let i = tokenizationResult1.tokens.length - 1; i >= 0; i--) {
-            const t = tokenizationResult1.tokens[i];
-            if (position.column - 1 >= t.startIndex) {
-                token1Index = i;
-                break;
-            }
-        }
-        let token2Index = 0;
-        for (let i = (tokenizationResult2.tokens.length >>> 1); i >= 0; i--) {
-            if (position.column - 1 >= tokenizationResult2.tokens[(i << 1)]) {
-                token2Index = i;
-                break;
-            }
-        }
-        return {
-            token: tokenizationResult1.tokens[token1Index],
-            metadata: this._decodeMetadata(tokenizationResult2.tokens[(token2Index << 1) + 1])
-        };
-    }
-    _getStateBeforeLine(grammar, lineNumber) {
-        let state = null;
-        for (let i = 1; i < lineNumber; i++) {
-            const tokenizationResult = grammar.tokenizeLine(this._model.getLineContent(i), state);
-            state = tokenizationResult.ruleStack;
-        }
-        return state;
-    }
-    isSemanticTokens(token) {
-        return token && token.data;
-    }
-    async _computeSemanticTokens(position) {
-        if (!this._isSemanticColoringEnabled()) {
-            return null;
-        }
-        const tokenProviders = this._languageFeaturesService.documentSemanticTokensProvider.ordered(this._model);
-        if (tokenProviders.length) {
-            const provider = tokenProviders[0];
-            const tokens = await Promise.resolve(provider.provideDocumentSemanticTokens(this._model, null, this._currentRequestCancellationTokenSource.token));
-            if (this.isSemanticTokens(tokens)) {
-                return { tokens, legend: provider.getLegend() };
-            }
-        }
-        const rangeTokenProviders = this._languageFeaturesService.documentRangeSemanticTokensProvider.ordered(this._model);
-        if (rangeTokenProviders.length) {
-            const provider = rangeTokenProviders[0];
-            const lineNumber = position.lineNumber;
-            const range = ( new Range(lineNumber, 1, lineNumber, this._model.getLineMaxColumn(lineNumber)));
-            const tokens = await Promise.resolve(provider.provideDocumentRangeSemanticTokens(this._model, range, this._currentRequestCancellationTokenSource.token));
-            if (this.isSemanticTokens(tokens)) {
-                return { tokens, legend: provider.getLegend() };
-            }
-        }
-        return null;
-    }
-    _getSemanticTokenAtPosition(semanticTokens, pos) {
-        const tokenData = semanticTokens.tokens.data;
-        const defaultLanguage = this._model.getLanguageId();
-        let lastLine = 0;
-        let lastCharacter = 0;
-        const posLine = pos.lineNumber - 1, posCharacter = pos.column - 1;
-        for (let i = 0; i < tokenData.length; i += 5) {
-            const lineDelta = tokenData[i], charDelta = tokenData[i + 1], len = tokenData[i + 2], typeIdx = tokenData[i + 3], modSet = tokenData[i + 4];
-            const line = lastLine + lineDelta;
-            const character = lineDelta === 0 ? lastCharacter + charDelta : charDelta;
-            if (posLine === line && character <= posCharacter && posCharacter < character + len) {
-                const type = semanticTokens.legend.tokenTypes[typeIdx] || 'not in legend (ignored)';
-                const modifiers = [];
-                let modifierSet = modSet;
-                for (let modifierIndex = 0; modifierSet > 0 && modifierIndex < semanticTokens.legend.tokenModifiers.length; modifierIndex++) {
-                    if (modifierSet & 1) {
-                        modifiers.push(semanticTokens.legend.tokenModifiers[modifierIndex]);
-                    }
-                    modifierSet = modifierSet >> 1;
-                }
-                if (modifierSet > 0) {
-                    modifiers.push('not in legend (ignored)');
-                }
-                const range = ( new Range(line + 1, character + 1, line + 1, character + 1 + len));
-                const definitions = {};
-                const colorMap = this._themeService.getColorTheme().tokenColorMap;
-                const theme = this._themeService.getColorTheme();
-                const tokenStyle = theme.getTokenStyleMetadata(type, modifiers, defaultLanguage, true, definitions);
-                let metadata = undefined;
-                if (tokenStyle) {
-                    metadata = {
-                        languageId: undefined,
-                        tokenType: 0 ,
-                        bold: tokenStyle?.bold,
-                        italic: tokenStyle?.italic,
-                        underline: tokenStyle?.underline,
-                        strikethrough: tokenStyle?.strikethrough,
-                        foreground: colorMap[tokenStyle?.foreground || 0 ],
-                        background: undefined
-                    };
-                }
-                return { type, modifiers, range, metadata, definitions };
-            }
-            lastLine = line;
-            lastCharacter = character;
-        }
-        return null;
-    }
-    _renderTokenStyleDefinition(definition, property) {
-        const elements = ( new Array());
-        if (definition === undefined) {
-            return elements;
-        }
-        const theme = this._themeService.getColorTheme();
-        if (Array.isArray(definition)) {
-            const scopesDefinition = {};
-            theme.resolveScopes(definition, scopesDefinition);
-            const matchingRule = scopesDefinition[property];
-            if (matchingRule && scopesDefinition.scope) {
-                const scopes = $('ul.tiw-metadata-values');
-                const strScopes = Array.isArray(matchingRule.scope) ? matchingRule.scope : [String(matchingRule.scope)];
-                for (const strScope of strScopes) {
-                    scopes.appendChild($('li.tiw-metadata-value.tiw-metadata-scopes', undefined, strScope));
-                }
-                elements.push(scopesDefinition.scope.join(' '), scopes, $('code.tiw-theme-selector', undefined, JSON.stringify(matchingRule.settings, null, '\t')));
-                return elements;
-            }
-            return elements;
-        }
-        else if (SemanticTokenRule.is(definition)) {
-            const scope = theme.getTokenStylingRuleScope(definition);
-            if (scope === 'setting') {
-                elements.push(`User settings: ${definition.selector.id} - ${this._renderStyleProperty(definition.style, property)}`);
-                return elements;
-            }
-            else if (scope === 'theme') {
-                elements.push(`Color theme: ${definition.selector.id} - ${this._renderStyleProperty(definition.style, property)}`);
-                return elements;
-            }
-            return elements;
-        }
-        else {
-            const style = theme.resolveTokenStyleValue(definition);
-            elements.push(`Default: ${style ? this._renderStyleProperty(style, property) : ''}`);
-            return elements;
-        }
-    }
-    _renderStyleProperty(style, property) {
-        switch (property) {
-            case 'foreground': return style.foreground ? Color.Format.CSS.formatHexA(style.foreground, true) : '';
-            default: return style[property] !== undefined ? String(style[property]) : '';
-        }
-    }
-    getDomNode() {
-        return this._domNode;
-    }
-    getPosition() {
-        return {
-            position: this._editor.getPosition(),
-            preference: [2 , 1 ]
-        };
-    }
-}
-registerEditorContribution(InspectEditorTokensController.ID, InspectEditorTokensController, 4 );
-registerEditorAction(InspectEditorTokens);

package/vscode/src/vs/workbench/services/textMate/common/TMHelper.js

@@ -1,107 +0,0 @@
-function findMatchingThemeRule(theme, scopes, onlyColorRules = true) {
-    for (let i = scopes.length - 1; i >= 0; i--) {
-        const parentScopes = scopes.slice(0, i);
-        const scope = scopes[i];
-        const r = findMatchingThemeRule2(theme, scope, parentScopes, onlyColorRules);
-        if (r) {
-            return r;
-        }
-    }
-    return null;
-}
-function findMatchingThemeRule2(theme, scope, parentScopes, onlyColorRules) {
-    let result = null;
-    for (let i = theme.tokenColors.length - 1; i >= 0; i--) {
-        const rule = theme.tokenColors[i];
-        if (onlyColorRules && !rule.settings.foreground) {
-            continue;
-        }
-        let selectors;
-        if (typeof rule.scope === 'string') {
-            selectors = ( rule.scope.split(/,/).map(scope => scope.trim()));
-        }
-        else if (Array.isArray(rule.scope)) {
-            selectors = rule.scope;
-        }
-        else {
-            continue;
-        }
-        for (let j = 0, lenJ = selectors.length; j < lenJ; j++) {
-            const rawSelector = selectors[j];
-            const themeRule = ( new ThemeRule(rawSelector, rule.settings));
-            if (themeRule.matches(scope, parentScopes)) {
-                if (themeRule.isMoreSpecific(result)) {
-                    result = themeRule;
-                }
-            }
-        }
-    }
-    return result;
-}
-class ThemeRule {
-    constructor(rawSelector, settings) {
-        this.rawSelector = rawSelector;
-        this.settings = settings;
-        const rawSelectorPieces = this.rawSelector.split(/ /);
-        this.scope = rawSelectorPieces[rawSelectorPieces.length - 1];
-        this.parentScopes = rawSelectorPieces.slice(0, rawSelectorPieces.length - 1);
-    }
-    matches(scope, parentScopes) {
-        return ThemeRule._matches(this.scope, this.parentScopes, scope, parentScopes);
-    }
-    static _cmp(a, b) {
-        if (a === null && b === null) {
-            return 0;
-        }
-        if (a === null) {
-            return -1;
-        }
-        if (b === null) {
-            return 1;
-        }
-        if (a.scope.length !== b.scope.length) {
-            return a.scope.length - b.scope.length;
-        }
-        const aParentScopesLen = a.parentScopes.length;
-        const bParentScopesLen = b.parentScopes.length;
-        if (aParentScopesLen !== bParentScopesLen) {
-            return aParentScopesLen - bParentScopesLen;
-        }
-        for (let i = 0; i < aParentScopesLen; i++) {
-            const aLen = a.parentScopes[i].length;
-            const bLen = b.parentScopes[i].length;
-            if (aLen !== bLen) {
-                return aLen - bLen;
-            }
-        }
-        return 0;
-    }
-    isMoreSpecific(other) {
-        return (ThemeRule._cmp(this, other) > 0);
-    }
-    static _matchesOne(selectorScope, scope) {
-        const selectorPrefix = selectorScope + '.';
-        if (selectorScope === scope || scope.substring(0, selectorPrefix.length) === selectorPrefix) {
-            return true;
-        }
-        return false;
-    }
-    static _matches(selectorScope, selectorParentScopes, scope, parentScopes) {
-        if (!this._matchesOne(selectorScope, scope)) {
-            return false;
-        }
-        let selectorParentIndex = selectorParentScopes.length - 1;
-        let parentIndex = parentScopes.length - 1;
-        while (selectorParentIndex >= 0 && parentIndex >= 0) {
-            if (this._matchesOne(selectorParentScopes[selectorParentIndex], parentScopes[parentIndex])) {
-                selectorParentIndex--;
-            }
-            parentIndex--;
-        }
-        if (selectorParentIndex === -1) {
-            return true;
-        }
-        return false;
-    }
-}
-export { ThemeRule, findMatchingThemeRule };