@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsOutline.js

@@ -0,0 +1,370 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { DisposableStore, Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { IOutlineService } from '../../../../services/outline/browser/outline.js';
+import { Extensions } from '../../../../common/contributions.js';
+import { Registry } from '../../../../../platform/registry/common/platform.js';
+import { DocumentSymbolGroupRenderer, DocumentSymbolRenderer, DocumentSymbolIdentityProvider, DocumentSymbolNavigationLabelProvider, DocumentSymbolAccessibilityProvider, DocumentSymbolFilter, DocumentSymbolVirtualDelegate, DocumentSymbolComparator } from './documentSymbolsTree.js';
+import { isCodeEditor, isDiffEditor } from '../../../../../editor/browser/editorBrowser.js';
+import { TreeElement, OutlineModel, OutlineElement, IOutlineModelService, OutlineGroup } from '../../../../../editor/contrib/documentSymbols/browser/outlineModel.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { raceCancellation, timeout, Barrier, TimeoutTimer } from '../../../../../base/common/async.js';
+import { onUnexpectedError } from '../../../../../base/common/errors.js';
+import { ITextResourceConfigurationService } from '../../../../../editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { ICodeEditorService } from '../../../../../editor/browser/services/codeEditorService.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IMarkerDecorationsService } from '../../../../../editor/common/services/markerDecorations.js';
+import { MarkerSeverity } from '../../../../../platform/markers/common/markers.js';
+import { isEqual } from '../../../../../base/common/resources.js';
+import { ILanguageFeaturesService } from '../../../../../editor/common/services/languageFeatures.js';
+let DocumentSymbolBreadcrumbsSource = class DocumentSymbolBreadcrumbsSource {
+    constructor(_editor, _textResourceConfigurationService) {
+        this._editor = _editor;
+        this._textResourceConfigurationService = _textResourceConfigurationService;
+        this._breadcrumbs = [];
+    }
+    getBreadcrumbElements() {
+        return this._breadcrumbs;
+    }
+    clear() {
+        this._breadcrumbs = [];
+    }
+    update(model, position) {
+        const newElements = this._computeBreadcrumbs(model, position);
+        this._breadcrumbs = newElements;
+    }
+    _computeBreadcrumbs(model, position) {
+        let item = model.getItemEnclosingPosition(position);
+        if (!item) {
+            return [];
+        }
+        const chain = [];
+        while (item) {
+            chain.push(item);
+            const parent = item.parent;
+            if (parent instanceof OutlineModel) {
+                break;
+            }
+            if (parent instanceof OutlineGroup && parent.parent && parent.parent.children.size === 1) {
+                break;
+            }
+            item = parent;
+        }
+        const result = [];
+        for (let i = chain.length - 1; i >= 0; i--) {
+            const element = chain[i];
+            if (this._isFiltered(element)) {
+                break;
+            }
+            result.push(element);
+        }
+        if (result.length === 0) {
+            return [];
+        }
+        return result;
+    }
+    _isFiltered(element) {
+        if (!(element instanceof OutlineElement)) {
+            return false;
+        }
+        const key = `breadcrumbs.${DocumentSymbolFilter.kindToConfigName[element.symbol.kind]}`;
+        let uri;
+        if (this._editor && this._editor.getModel()) {
+            const model = this._editor.getModel();
+            uri = model.uri;
+        }
+        return !this._textResourceConfigurationService.getValue(uri, key);
+    }
+};
+DocumentSymbolBreadcrumbsSource = ( __decorate([
+    ( __param(1, ITextResourceConfigurationService))
+], DocumentSymbolBreadcrumbsSource));
+let DocumentSymbolsOutline = class DocumentSymbolsOutline {
+    get activeElement() {
+        const posistion = this._editor.getPosition();
+        if (!posistion || !this._outlineModel) {
+            return undefined;
+        }
+        else {
+            return this._outlineModel.getItemEnclosingPosition(posistion);
+        }
+    }
+    constructor(_editor, target, firstLoadBarrier, _languageFeaturesService, _codeEditorService, _outlineModelService, _configurationService, _markerDecorationsService, textResourceConfigurationService, instantiationService) {
+        this._editor = _editor;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._codeEditorService = _codeEditorService;
+        this._outlineModelService = _outlineModelService;
+        this._configurationService = _configurationService;
+        this._markerDecorationsService = _markerDecorationsService;
+        this._disposables = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._outlineDisposables = ( new DisposableStore());
+        this.outlineKind = 'documentSymbols';
+        this._breadcrumbsDataSource = ( new DocumentSymbolBreadcrumbsSource(_editor, textResourceConfigurationService));
+        const delegate = ( new DocumentSymbolVirtualDelegate());
+        const renderers = [( new DocumentSymbolGroupRenderer()), instantiationService.createInstance(DocumentSymbolRenderer, true, target)];
+        const treeDataSource = {
+            getChildren: (parent) => {
+                if (parent instanceof OutlineElement || parent instanceof OutlineGroup) {
+                    return ( parent.children.values());
+                }
+                if (parent === this && this._outlineModel) {
+                    return ( this._outlineModel.children.values());
+                }
+                return [];
+            }
+        };
+        const comparator = ( new DocumentSymbolComparator());
+        const initialState = textResourceConfigurationService.getValue(_editor.getModel()?.uri, "outline.collapseItems" );
+        const options = {
+            collapseByDefault: target === 2  || ((target === 1  && initialState === "alwaysCollapse") ),
+            expandOnlyOnTwistieClick: true,
+            multipleSelectionSupport: false,
+            identityProvider: ( new DocumentSymbolIdentityProvider()),
+            keyboardNavigationLabelProvider: ( new DocumentSymbolNavigationLabelProvider()),
+            accessibilityProvider: ( new DocumentSymbolAccessibilityProvider(( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsOutline',
+                'document',
+                "Document Symbols"
+            )))),
+            filter: target === 1
+                ? instantiationService.createInstance(DocumentSymbolFilter, 'outline')
+                : target === 2
+                    ? instantiationService.createInstance(DocumentSymbolFilter, 'breadcrumbs')
+                    : undefined
+        };
+        this.config = {
+            breadcrumbsDataSource: this._breadcrumbsDataSource,
+            delegate,
+            renderers,
+            treeDataSource,
+            comparator,
+            options,
+            quickPickDataSource: { getQuickPickElements: () => { throw new Error('not implemented'); } }
+        };
+        this._disposables.add(_languageFeaturesService.documentSymbolProvider.onDidChange(_ => this._createOutline()));
+        this._disposables.add(this._editor.onDidChangeModel(_ => this._createOutline()));
+        this._disposables.add(this._editor.onDidChangeModelLanguage(_ => this._createOutline()));
+        const updateSoon = ( new TimeoutTimer());
+        this._disposables.add(updateSoon);
+        this._disposables.add(this._editor.onDidChangeModelContent(event => {
+            const model = this._editor.getModel();
+            if (model) {
+                const timeout = _outlineModelService.getDebounceValue(model);
+                updateSoon.cancelAndSet(() => this._createOutline(event), timeout);
+            }
+        }));
+        this._disposables.add(this._editor.onDidDispose(() => this._outlineDisposables.clear()));
+        this._createOutline().finally(() => firstLoadBarrier.open());
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._outlineDisposables.dispose();
+    }
+    get isEmpty() {
+        return !this._outlineModel || TreeElement.empty(this._outlineModel);
+    }
+    get uri() {
+        return this._outlineModel?.uri;
+    }
+    async reveal(entry, options, sideBySide, select) {
+        const model = OutlineModel.get(entry);
+        if (!model || !(entry instanceof OutlineElement)) {
+            return;
+        }
+        await this._codeEditorService.openCodeEditor({
+            resource: model.uri,
+            options: {
+                ...options,
+                selection: select ? entry.symbol.range : Range.collapseToStart(entry.symbol.selectionRange),
+                selectionRevealType: 3 ,
+            }
+        }, this._editor, sideBySide);
+    }
+    preview(entry) {
+        if (!(entry instanceof OutlineElement)) {
+            return Disposable.None;
+        }
+        const { symbol } = entry;
+        this._editor.revealRangeInCenterIfOutsideViewport(symbol.range, 0 );
+        const decorationsCollection = this._editor.createDecorationsCollection([{
+                range: symbol.range,
+                options: {
+                    description: 'document-symbols-outline-range-highlight',
+                    className: 'rangeHighlight',
+                    isWholeLine: true
+                }
+            }]);
+        return toDisposable(() => decorationsCollection.clear());
+    }
+    captureViewState() {
+        const viewState = this._editor.saveViewState();
+        return toDisposable(() => {
+            if (viewState) {
+                this._editor.restoreViewState(viewState);
+            }
+        });
+    }
+    async _createOutline(contentChangeEvent) {
+        this._outlineDisposables.clear();
+        if (!contentChangeEvent) {
+            this._setOutlineModel(undefined);
+        }
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const buffer = this._editor.getModel();
+        if (!( this._languageFeaturesService.documentSymbolProvider.has(buffer))) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        const versionIdThen = buffer.getVersionId();
+        const timeoutTimer = ( new TimeoutTimer());
+        this._outlineDisposables.add(timeoutTimer);
+        this._outlineDisposables.add(toDisposable(() => cts.dispose(true)));
+        try {
+            const model = await this._outlineModelService.getOrCreate(buffer, cts.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (TreeElement.empty(model) || !this._editor.hasModel()) {
+                this._setOutlineModel(model);
+                return;
+            }
+            if (contentChangeEvent && this._outlineModel && buffer.getLineCount() >= 25) {
+                const newSize = TreeElement.size(model);
+                const newLength = buffer.getValueLength();
+                const newRatio = newSize / newLength;
+                const oldSize = TreeElement.size(this._outlineModel);
+                const oldLength = newLength - contentChangeEvent.changes.reduce((prev, value) => prev + value.rangeLength, 0);
+                const oldRatio = oldSize / oldLength;
+                if (newRatio <= oldRatio * 0.5 || newRatio >= oldRatio * 1.5) {
+                    const value = await raceCancellation(timeout(2000).then(() => true), cts.token, false);
+                    if (!value) {
+                        return;
+                    }
+                }
+            }
+            this._applyMarkersToOutline(model);
+            this._outlineDisposables.add(this._markerDecorationsService.onDidChangeMarker(textModel => {
+                if (isEqual(model.uri, textModel.uri)) {
+                    this._applyMarkersToOutline(model);
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration("outline.problems.enabled" ) || e.affectsConfiguration('problems.visibility')) {
+                    const problem = this._configurationService.getValue('problems.visibility');
+                    const config = this._configurationService.getValue("outline.problems.enabled" );
+                    if (!problem || !config) {
+                        model.updateMarker([]);
+                    }
+                    else {
+                        this._applyMarkersToOutline(model);
+                    }
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('outline')) {
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('breadcrumbs') && this._editor.hasModel()) {
+                    this._breadcrumbsDataSource.update(model, this._editor.getPosition());
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration("outline.icons" )) {
+                    this._onDidChange.fire({});
+                }
+                if (e.affectsConfiguration('outline')) {
+                    this._onDidChange.fire({});
+                }
+            }));
+            this._outlineDisposables.add(this._editor.onDidChangeCursorPosition(_ => {
+                timeoutTimer.cancelAndSet(() => {
+                    if (!buffer.isDisposed() && versionIdThen === buffer.getVersionId() && this._editor.hasModel()) {
+                        this._breadcrumbsDataSource.update(model, this._editor.getPosition());
+                        this._onDidChange.fire({ affectOnlyActiveElement: true });
+                    }
+                }, 150);
+            }));
+            this._setOutlineModel(model);
+        }
+        catch (err) {
+            this._setOutlineModel(undefined);
+            onUnexpectedError(err);
+        }
+    }
+    _applyMarkersToOutline(model) {
+        const problem = this._configurationService.getValue('problems.visibility');
+        const config = this._configurationService.getValue("outline.problems.enabled" );
+        if (!model || !problem || !config) {
+            return;
+        }
+        const markers = [];
+        for (const [range, marker] of this._markerDecorationsService.getLiveMarkers(model.uri)) {
+            if (marker.severity === MarkerSeverity.Error || marker.severity === MarkerSeverity.Warning) {
+                markers.push({ ...range, severity: marker.severity });
+            }
+        }
+        model.updateMarker(markers);
+    }
+    _setOutlineModel(model) {
+        const position = this._editor.getPosition();
+        if (!position || !model) {
+            this._outlineModel = undefined;
+            this._breadcrumbsDataSource.clear();
+        }
+        else {
+            if (!this._outlineModel?.merge(model)) {
+                this._outlineModel = model;
+            }
+            this._breadcrumbsDataSource.update(model, position);
+        }
+        this._onDidChange.fire({});
+    }
+};
+DocumentSymbolsOutline = ( __decorate([
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IOutlineModelService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IMarkerDecorationsService)),
+    ( __param(8, ITextResourceConfigurationService)),
+    ( __param(9, IInstantiationService))
+], DocumentSymbolsOutline));
+let DocumentSymbolsOutlineCreator = class DocumentSymbolsOutlineCreator {
+    constructor(outlineService) {
+        const reg = outlineService.registerOutlineCreator(this);
+        this.dispose = () => reg.dispose();
+    }
+    matches(candidate) {
+        const ctrl = candidate.getControl();
+        return isCodeEditor(ctrl) || isDiffEditor(ctrl);
+    }
+    async createOutline(pane, target, _token) {
+        const control = pane.getControl();
+        let editor;
+        if (isCodeEditor(control)) {
+            editor = control;
+        }
+        else if (isDiffEditor(control)) {
+            editor = control.getModifiedEditor();
+        }
+        if (!editor) {
+            return undefined;
+        }
+        const firstLoadBarrier = ( new Barrier());
+        const result = editor.invokeWithinContext(accessor => accessor.get(IInstantiationService).createInstance(DocumentSymbolsOutline, editor, target, firstLoadBarrier));
+        await firstLoadBarrier.wait();
+        return result;
+    }
+};
+DocumentSymbolsOutlineCreator = ( __decorate([
+    ( __param(0, IOutlineService))
+], DocumentSymbolsOutlineCreator));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DocumentSymbolsOutlineCreator, 4 );

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-list .monaco-list-row.focused.selected .outline-element .monaco-highlighted-label,.monaco-list .monaco-list-row.focused.selected .outline-element-decoration{color:inherit!important}.monaco-list .outline-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-list .outline-element .monaco-highlighted-label{color:var(--outline-element-color)}.monaco-breadcrumbs .outline-element .outline-element-decoration,.monaco-list .outline-element .outline-element-decoration{color:var(--outline-element-color);font-size:90%;font-weight:600;margin-left:auto;opacity:.75;padding:0 12px 0 5px;text-align:center}.monaco-breadcrumbs .outline-element .monaco-icon-label-container .monaco-icon-description-container,.monaco-breadcrumbs .outline-element .outline-element-decoration{display:none}.monaco-list .outline-element .outline-element-decoration.bubble{font-family:codicon;font-size:14px;opacity:.4;padding-right:8px}.monaco-list .outline-element .outline-element-icon{margin-right:4px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree.js

@@ -0,0 +1,290 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './documentSymbolsTree.css.js';
+import '../../../../../editor/contrib/symbolIcons/browser/symbolIcons.js';
+import { $, append, hide, show, WindowIdleValue } from '../../../../../base/browser/dom.js';
+import { HighlightedLabel } from '../../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
+import { createMatches } from '../../../../../base/common/filters.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { getAriaLabelForSymbol, symbolKindNames, SymbolKinds } from '../../../../../editor/common/languages.js';
+import { OutlineElement, OutlineModel, OutlineGroup } from '../../../../../editor/contrib/documentSymbols/browser/outlineModel.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IconLabel } from '../../../../../base/browser/ui/iconLabel/iconLabel.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { MarkerSeverity } from '../../../../../platform/markers/common/markers.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import '../../../../../platform/theme/common/colorUtils.js';
+import '../../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../../platform/theme/common/colors/inputColors.js';
+import { listErrorForeground, listWarningForeground } from '../../../../../platform/theme/common/colors/listColors.js';
+import '../../../../../platform/theme/common/colors/menuColors.js';
+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';
+import { ITextResourceConfigurationService } from '../../../../../editor/common/services/textResourceConfiguration.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { mainWindow } from '../../../../../base/browser/window.js';
+var DocumentSymbolFilter_1;
+class DocumentSymbolNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        if (element instanceof OutlineGroup) {
+            return element.label;
+        }
+        else {
+            return element.symbol.name;
+        }
+    }
+}
+class DocumentSymbolAccessibilityProvider {
+    constructor(_ariaLabel) {
+        this._ariaLabel = _ariaLabel;
+    }
+    getWidgetAriaLabel() {
+        return this._ariaLabel;
+    }
+    getAriaLabel(element) {
+        if (element instanceof OutlineGroup) {
+            return element.label;
+        }
+        else {
+            return getAriaLabelForSymbol(element.symbol.name, element.symbol.kind);
+        }
+    }
+}
+class DocumentSymbolIdentityProvider {
+    getId(element) {
+        return element.id;
+    }
+}
+class DocumentSymbolGroupTemplate {
+    static { this.id = 'DocumentSymbolGroupTemplate'; }
+    constructor(labelContainer, label) {
+        this.labelContainer = labelContainer;
+        this.label = label;
+    }
+    dispose() {
+        this.label.dispose();
+    }
+}
+class DocumentSymbolTemplate {
+    static { this.id = 'DocumentSymbolTemplate'; }
+    constructor(container, iconLabel, iconClass, decoration) {
+        this.container = container;
+        this.iconLabel = iconLabel;
+        this.iconClass = iconClass;
+        this.decoration = decoration;
+    }
+}
+class DocumentSymbolVirtualDelegate {
+    getHeight(_element) {
+        return 22;
+    }
+    getTemplateId(element) {
+        return element instanceof OutlineGroup
+            ? DocumentSymbolGroupTemplate.id
+            : DocumentSymbolTemplate.id;
+    }
+}
+class DocumentSymbolGroupRenderer {
+    constructor() {
+        this.templateId = DocumentSymbolGroupTemplate.id;
+    }
+    renderTemplate(container) {
+        const labelContainer = $('.outline-element-label');
+        container.classList.add('outline-element');
+        append(container, labelContainer);
+        return ( new DocumentSymbolGroupTemplate(labelContainer, ( new HighlightedLabel(labelContainer))));
+    }
+    renderElement(node, _index, template) {
+        template.label.set(node.element.label, createMatches(node.filterData));
+    }
+    disposeTemplate(_template) {
+        _template.dispose();
+    }
+}
+let DocumentSymbolRenderer = class DocumentSymbolRenderer {
+    constructor(_renderMarker, target, _configurationService, _themeService) {
+        this._renderMarker = _renderMarker;
+        this._configurationService = _configurationService;
+        this._themeService = _themeService;
+        this.templateId = DocumentSymbolTemplate.id;
+    }
+    renderTemplate(container) {
+        container.classList.add('outline-element');
+        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
+        const iconClass = $('.outline-element-icon');
+        const decoration = $('.outline-element-decoration');
+        container.prepend(iconClass);
+        container.appendChild(decoration);
+        return ( new DocumentSymbolTemplate(container, iconLabel, iconClass, decoration));
+    }
+    renderElement(node, _index, template) {
+        const { element } = node;
+        const extraClasses = ['nowrap'];
+        const options = {
+            matches: createMatches(node.filterData),
+            labelEscapeNewLines: true,
+            extraClasses,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree',
+                'title.template',
+                "{0} ({1})",
+                element.symbol.name,
+                symbolKindNames[element.symbol.kind]
+            ))
+        };
+        if (this._configurationService.getValue("outline.icons" )) {
+            template.iconClass.className = '';
+            template.iconClass.classList.add('outline-element-icon', 'inline', ...ThemeIcon.asClassNameArray(SymbolKinds.toIcon(element.symbol.kind)));
+        }
+        if (element.symbol.tags.indexOf(1 ) >= 0) {
+            extraClasses.push(`deprecated`);
+            options.matches = [];
+        }
+        template.iconLabel.setLabel(element.symbol.name, element.symbol.detail, options);
+        if (this._renderMarker) {
+            this._renderMarkerInfo(element, template);
+        }
+    }
+    _renderMarkerInfo(element, template) {
+        if (!element.marker) {
+            hide(template.decoration);
+            template.container.style.removeProperty('--outline-element-color');
+            return;
+        }
+        const { count, topSev } = element.marker;
+        const color = this._themeService.getColorTheme().getColor(topSev === MarkerSeverity.Error ? listErrorForeground : listWarningForeground);
+        const cssColor = color ? ( color.toString()) : 'inherit';
+        const problem = this._configurationService.getValue('problems.visibility');
+        const configProblems = this._configurationService.getValue("outline.problems.colors" );
+        if (!problem || !configProblems) {
+            template.container.style.removeProperty('--outline-element-color');
+        }
+        else {
+            template.container.style.setProperty('--outline-element-color', cssColor);
+        }
+        if (problem === undefined) {
+            return;
+        }
+        const configBadges = this._configurationService.getValue("outline.problems.badges" );
+        if (!configBadges || !problem) {
+            hide(template.decoration);
+        }
+        else if (count > 0) {
+            show(template.decoration);
+            template.decoration.classList.remove('bubble');
+            template.decoration.innerText = count < 10 ? ( count.toString()) : '+9';
+            template.decoration.title = count === 1 ? ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree',
+                '1.problem',
+                "1 problem in this element"
+            )) : ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree',
+                'N.problem',
+                "{0} problems in this element",
+                count
+            ));
+            template.decoration.style.setProperty('--outline-element-color', cssColor);
+        }
+        else {
+            show(template.decoration);
+            template.decoration.classList.add('bubble');
+            template.decoration.innerText = '\uea71';
+            template.decoration.title = ( localizeWithPath(
+                'vs/workbench/contrib/codeEditor/browser/outline/documentSymbolsTree',
+                'deep.problem',
+                "Contains elements with problems"
+            ));
+            template.decoration.style.setProperty('--outline-element-color', cssColor);
+        }
+    }
+    disposeTemplate(_template) {
+        _template.iconLabel.dispose();
+    }
+};
+DocumentSymbolRenderer = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IThemeService))
+], DocumentSymbolRenderer));
+let DocumentSymbolFilter = class DocumentSymbolFilter {
+    static { DocumentSymbolFilter_1 = this; }
+    static { this.kindToConfigName = ( Object.freeze({
+        [0 ]: 'showFiles',
+        [1 ]: 'showModules',
+        [2 ]: 'showNamespaces',
+        [3 ]: 'showPackages',
+        [4 ]: 'showClasses',
+        [5 ]: 'showMethods',
+        [6 ]: 'showProperties',
+        [7 ]: 'showFields',
+        [8 ]: 'showConstructors',
+        [9 ]: 'showEnums',
+        [10 ]: 'showInterfaces',
+        [11 ]: 'showFunctions',
+        [12 ]: 'showVariables',
+        [13 ]: 'showConstants',
+        [14 ]: 'showStrings',
+        [15 ]: 'showNumbers',
+        [16 ]: 'showBooleans',
+        [17 ]: 'showArrays',
+        [18 ]: 'showObjects',
+        [19 ]: 'showKeys',
+        [20 ]: 'showNull',
+        [21 ]: 'showEnumMembers',
+        [22 ]: 'showStructs',
+        [23 ]: 'showEvents',
+        [24 ]: 'showOperators',
+        [25 ]: 'showTypeParameters',
+    })); }
+    constructor(_prefix, _textResourceConfigService) {
+        this._prefix = _prefix;
+        this._textResourceConfigService = _textResourceConfigService;
+    }
+    filter(element) {
+        const outline = OutlineModel.get(element);
+        if (!(element instanceof OutlineElement)) {
+            return true;
+        }
+        const configName = DocumentSymbolFilter_1.kindToConfigName[element.symbol.kind];
+        const configKey = `${this._prefix}.${configName}`;
+        return this._textResourceConfigService.getValue(outline?.uri, configKey);
+    }
+};
+DocumentSymbolFilter = DocumentSymbolFilter_1 = ( __decorate([
+    ( __param(1, ITextResourceConfigurationService))
+], DocumentSymbolFilter));
+class DocumentSymbolComparator {
+    constructor() {
+        this._collator = new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true }));
+    }
+    compareByPosition(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return Range.compareRangesUsingStarts(a.symbol.range, b.symbol.range) || this._collator.value.compare(a.symbol.name, b.symbol.name);
+        }
+        return 0;
+    }
+    compareByType(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return a.symbol.kind - b.symbol.kind || this._collator.value.compare(a.symbol.name, b.symbol.name);
+        }
+        return 0;
+    }
+    compareByName(a, b) {
+        if (a instanceof OutlineGroup && b instanceof OutlineGroup) {
+            return a.order - b.order;
+        }
+        else if (a instanceof OutlineElement && b instanceof OutlineElement) {
+            return this._collator.value.compare(a.symbol.name, b.symbol.name) || Range.compareRangesUsingStarts(a.symbol.range, b.symbol.range);
+        }
+        return 0;
+    }
+}
+export { DocumentSymbolAccessibilityProvider, DocumentSymbolComparator, DocumentSymbolFilter, DocumentSymbolGroupRenderer, DocumentSymbolIdentityProvider, DocumentSymbolNavigationLabelProvider, DocumentSymbolRenderer, DocumentSymbolVirtualDelegate };