@codingame/monaco-vscode-api 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/codeEditor/browser/find/simpleFindWidget.js

@@ -3,7 +3,6 @@ import { localize } from '../../../../../nls.js';
 import { trackFocus, addDisposableListener, getComputedStyle } from '../../../../../base/browser/dom.js';
 import { Widget } from '../../../../../base/browser/ui/widget.js';
 import { Delayer } from '../../../../../base/common/async.js';
-import { KeyCode } from '../../../../../base/common/keyCodes.js';
 import { FindReplaceState } from '../../../../../editor/contrib/find/browser/findState.js';
 import { SimpleButton, findPreviousMatchIcon, findNextMatchIcon, NLS_MATCHES_LOCATION, NLS_NO_RESULTS } from '../../../../../editor/contrib/find/browser/findWidget.js';
 import { ContextScopedFindInput } from '../../../../../platform/history/browser/contextScopedHistoryWidget.js';
@@ -13,7 +12,7 @@ import { format } from '../../../../../base/common/strings.js';
 import { showHistoryKeybindingHint } from '../../../../../platform/history/browser/historyWidgetKeybindingHint.js';
 import { status } from '../../../../../base/browser/ui/aria/aria.js';
 import { defaultInputBoxStyles, defaultToggleStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
-import { Sash, Orientation } from '../../../../../base/browser/ui/sash/sash.js';
+import { Sash } from '../../../../../base/browser/ui/sash/sash.js';
 import { registerColor } from '../../../../../platform/theme/common/colorUtils.js';
 import '../../../../../platform/theme/common/colors/baseColors.js';
 import '../../../../../platform/theme/common/colors/chartsColors.js';
@@ -25,11 +24,11 @@ import '../../../../../platform/theme/common/colors/minimapColors.js';
 import '../../../../../platform/theme/common/colors/miscColors.js';
 import '../../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../../platform/theme/common/colors/searchColors.js';
-const NLS_FIND_INPUT_LABEL = ( localize(11524, "Find"));
-const NLS_FIND_INPUT_PLACEHOLDER = ( localize(11525, "Find"));
-const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(11526, "Previous Match"));
-const NLS_NEXT_MATCH_BTN_LABEL = ( localize(11527, "Next Match"));
-const NLS_CLOSE_BTN_LABEL = ( localize(11528, "Close"));
+const NLS_FIND_INPUT_LABEL = ( localize(11668, "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( localize(11669, "Find"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(11670, "Previous Match"));
+const NLS_NEXT_MATCH_BTN_LABEL = ( localize(11671, "Next Match"));
+const NLS_CLOSE_BTN_LABEL = ( localize(11672, "Close"));
 const SIMPLE_FIND_WIDGET_INITIAL_WIDTH = 310;
 const MATCHES_COUNT_WIDTH = 73;
 class SimpleFindWidget extends Widget {
@@ -125,7 +124,7 @@ class SimpleFindWidget extends Widget {
         this._domNode.classList.add('simple-find-part-wrapper');
         this._domNode.appendChild(this._innerDomNode);
         this.onkeyup(this._innerDomNode, e => {
-            if (e.equals(KeyCode.Escape)) {
+            if (e.equals(9 )) {
                 this.hide();
                 e.preventDefault();
                 return;
@@ -163,7 +162,11 @@ class SimpleFindWidget extends Widget {
         if (options?.enableSash) {
             const _initialMinWidth = initialMinWidth ?? SIMPLE_FIND_WIDGET_INITIAL_WIDTH;
             let originalWidth = _initialMinWidth;
-            const resizeSash = this._register(( (new Sash(this._innerDomNode, this, { orientation: Orientation.VERTICAL, size: 1 }))));
+            const resizeSash = this._register(( (new Sash(
+                this._innerDomNode,
+                this,
+                { orientation: 0 , size: 1 }
+            ))));
             this._register(resizeSash.onDidStart(() => {
                 originalWidth = parseFloat(getComputedStyle(this._domNode).width);
             }));
@@ -331,17 +334,17 @@ class SimpleFindWidget extends Widget {
     }
     _announceSearchResults(label, searchString) {
         if (!searchString) {
-            return ( localize(11529, "Enter search input"));
+            return ( localize(11673, "Enter search input"));
         }
         if (label === NLS_NO_RESULTS) {
             return searchString === ''
-                ? ( localize(11530, "{0} found", label))
-                : ( localize(11531, "{0} found for '{1}'", label, searchString));
+                ? ( localize(11674, "{0} found", label))
+                : ( localize(11675, "{0} found for '{1}'", label, searchString));
         }
-        return ( localize(11532, "{0} found for '{1}'", label, searchString));
+        return ( localize(11676, "{0} found for '{1}'", label, searchString));
     }
 }
-const simpleFindWidgetSashBorder = registerColor('simpleFindWidget.sashBorder', { dark: '#454545', light: '#C8C8C8', hcDark: '#6FC3DF', hcLight: '#0F4A85' }, ( localize(11533, 'Border color of the sash border.')));
+const simpleFindWidgetSashBorder = registerColor('simpleFindWidget.sashBorder', { dark: '#454545', light: '#C8C8C8', hcDark: '#6FC3DF', hcLight: '#0F4A85' }, ( localize(11677, 'Border color of the sash border.')));
 registerThemingParticipant((theme, collector) => {
     const resizeBorderBackground = theme.getColor(simpleFindWidgetSashBorder);
     collector.addRule(`.monaco-workbench .simple-find-part .monaco-sash { background-color: ${resizeBorderBackground}; border-color: ${resizeBorderBackground} }`);

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".token-inspect-widget{border:1px solid var(--vscode-editorHoverWidget-border);padding:10px;user-select:text;-webkit-user-select:text;z-index:50}.hc-black .tokens-inspect-widget,.hc-light .tokens-inspect-widget{border-width:2px}.monaco-editor .token-inspect-widget{background-color:var(--vscode-editorHoverWidget-background)}.monaco-editor .token-inspect-widget .tiw-metadata-separator{background-color:var(--vscode-editorHoverWidget-border)}.tiw-token{font-family:var(--monaco-monospace-font)}.tiw-metadata-separator{border:0;height:1px}.tiw-token-length{float:right;font-size:60%;font-weight:400}.tiw-metadata-table{width:100%}.tiw-metadata-value{font-family:var(--monaco-monospace-font);word-break:break-word}.tiw-metadata-values{list-style:none;margin-right:-10px;max-height:300px;overflow-y:auto;padding-left:0}.tiw-metadata-values>.tiw-metadata-value{margin-right:10px}.tiw-metadata-key{min-width:150px;padding-right:10px;vertical-align:top;white-space:nowrap;width:1px}.tiw-metadata-semantic{font-style:italic}.tiw-metadata-scopes{line-height:normal}.tiw-theme-selector{font-family:var(--monaco-monospace-font)}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,545 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './inspectEditorTokens.css.js';
+import { localize } from '../../../../../nls.js';
+import { clearNode, reset, append, isHTMLElement, $ 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 { TreeSitterTokenizationRegistry } from '../../../../../editor/common/languages.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';
+import { ITreeSitterParserService } from '../../../../../editor/common/services/treeSitterParserService.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, treeSitterService, languageService, themeService, notificationService, configurationService, languageFeaturesService) {
+        super();
+        this._editor = editor;
+        this._textMateService = textMateService;
+        this._treeSitterService = treeSitterService;
+        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._treeSitterService,
+            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, ITreeSitterParserService))),
+    ( (__param(3, ILanguageService))),
+    ( (__param(4, IWorkbenchThemeService))),
+    ( (__param(5, INotificationService))),
+    ( (__param(6, IConfigurationService))),
+    ( (__param(7, ILanguageFeaturesService)))
+], InspectEditorTokensController)));
+class InspectEditorTokens extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.inspectTMScopes',
+            label: ( localize(3117, "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, treeSitterService, 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._treeSitterService = treeSitterService;
+        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);
+        const tree = this._treeSitterService.getParseResult(this._model);
+        clearNode(this._domNode);
+        this._domNode.appendChild(document.createTextNode(( localize(3118, "Loading..."))));
+        Promise.all([grammar, semanticTokens]).then(([grammar, semanticTokens]) => {
+            if (this._isDisposed) {
+                return;
+            }
+            this._compute(grammar, semanticTokens, tree?.tree, 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, tree, position) {
+        const textMateTokenInfo = grammar && this._getTokensAtPosition(grammar, position);
+        const semanticTokenInfo = semanticTokens && this._getSemanticTokenAtPosition(semanticTokens, position);
+        const treeSitterTokenInfo = tree && this._getTreeSitterTokenAtPosition(tree, position);
+        if (!textMateTokenInfo && !semanticTokenInfo && !treeSitterTokenInfo) {
+            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 => isHTMLElement(el) ? 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')));
+            }
+        }
+        if (treeSitterTokenInfo) {
+            append(this._domNode, $('hr.tiw-metadata-separator'));
+            const table = append(this._domNode, $('table.tiw-metadata-table'));
+            const tbody = append(table, $('tbody'));
+            append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'tree-sitter token'), $('td.tiw-metadata-value', undefined, `${treeSitterTokenInfo.text}`)));
+            const scopes = ( (new Array()));
+            let node = treeSitterTokenInfo;
+            while (node.parent) {
+                scopes.push(node.type);
+                node = node.parent;
+                if (node) {
+                    scopes.push($('br'));
+                }
+            }
+            append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'tree-sitter scopes'), $('td.tiw-metadata-value.tiw-metadata-scopes', undefined, ...scopes)));
+            const tokenizationSupport = TreeSitterTokenizationRegistry.get(this._model.getLanguageId());
+            const captures = tokenizationSupport?.captureAtPosition(position.lineNumber, position.column, this._model);
+            if (captures && captures.length > 0) {
+                append(tbody, $('tr', undefined, $('td.tiw-metadata-key', undefined, 'foreground'), $('td.tiw-metadata-value', undefined, captures[captures.length - 1].name)));
+            }
+        }
+    }
+    _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;
+    }
+    _walkTreeforPosition(cursor, pos) {
+        const offset = this._model.getOffsetAt(pos);
+        cursor.gotoFirstChild();
+        let goChild = false;
+        let lastGoodNode = null;
+        do {
+            if (cursor.currentNode.startIndex <= offset && offset < cursor.currentNode.endIndex) {
+                goChild = true;
+                lastGoodNode = cursor.currentNode;
+            }
+            else {
+                goChild = false;
+            }
+        } while (goChild ? cursor.gotoFirstChild() : cursor.gotoNextSibling());
+        return lastGoodNode;
+    }
+    _getTreeSitterTokenAtPosition(tree, pos) {
+        const cursor = tree.walk();
+        return this._walkTreeforPosition(cursor, pos);
+    }
+    _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);
+export { InspectEditorTokensController };