@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

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

@@ -1,362 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore, Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IOutlineService } from '../../../../services/outline/browser/outline.js';
-import { Extensions } from '../../../../common/contributions.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { DocumentSymbolGroupRenderer, DocumentSymbolRenderer, DocumentSymbolIdentityProvider, DocumentSymbolNavigationLabelProvider, DocumentSymbolAccessibilityProvider, DocumentSymbolFilter, DocumentSymbolVirtualDelegate, DocumentSymbolComparator } from './documentSymbolsTree.js';
-import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { TreeElement, OutlineModel, OutlineElement, IOutlineModelService, OutlineGroup } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { raceCancellation, timeout, Barrier, TimeoutTimer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IMarkerDecorationsService } from 'monaco-editor/esm/vs/editor/common/services/markerDecorations.js';
-import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
-import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/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)];
-        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(( localize('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) {
-        const model = OutlineModel.get(entry);
-        if (!model || !(entry instanceof OutlineElement)) {
-            return;
-        }
-        await this._codeEditorService.openCodeEditor({
-            resource: model.uri,
-            options: {
-                ...options,
-                selection: 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" )) {
-                    if (this._configurationService.getValue("outline.problems.enabled" )) {
-                        this._applyMarkersToOutline(model);
-                    }
-                    else {
-                        model.updateMarker([]);
-                    }
-                    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) {
-        if (!model || !this._configurationService.getValue("outline.problems.enabled" )) {
-            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

@@ -1,4 +0,0 @@
-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

@@ -1,255 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './documentSymbolsTree.css.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
-import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { getAriaLabelForSymbol, symbolKindNames, SymbolKinds } from 'monaco-editor/esm/vs/editor/common/languages.js';
-import { OutlineModel, OutlineElement, OutlineGroup } from 'monaco-editor/esm/vs/editor/contrib/documentSymbols/browser/outlineModel.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { listErrorForeground, listWarningForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { IdleValue } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.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;
-    }
-}
-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 = dom.$('.outline-element-label');
-        container.classList.add('outline-element');
-        dom.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) {
-    }
-}
-let DocumentSymbolRenderer = class DocumentSymbolRenderer {
-    constructor(_renderMarker, _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 = dom.$('.outline-element-icon');
-        const decoration = dom.$('.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: ( localize(
-                '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) {
-            dom.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';
-        if (this._configurationService.getValue("outline.problems.colors" )) {
-            template.container.style.setProperty('--outline-element-color', cssColor);
-        }
-        else {
-            template.container.style.removeProperty('--outline-element-color');
-        }
-        if (!this._configurationService.getValue("outline.problems.badges" )) {
-            dom.hide(template.decoration);
-        }
-        else if (count > 0) {
-            dom.show(template.decoration);
-            template.decoration.classList.remove('bubble');
-            template.decoration.innerText = count < 10 ? ( count.toString()) : '+9';
-            template.decoration.title = count === 1 ? ( localize('1.problem', "1 problem in this element")) : ( localize('N.problem', "{0} problems in this element", count));
-            template.decoration.style.setProperty('--outline-element-color', cssColor);
-        }
-        else {
-            dom.show(template.decoration);
-            template.decoration.classList.add('bubble');
-            template.decoration.innerText = '\uea71';
-            template.decoration.title = ( localize('deep.problem', "Contains elements with problems"));
-            template.decoration.style.setProperty('--outline-element-color', cssColor);
-        }
-    }
-    disposeTemplate(_template) {
-        _template.iconLabel.dispose();
-    }
-};
-DocumentSymbolRenderer = ( __decorate([
-    ( __param(1, IConfigurationService)),
-    ( __param(2, 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 IdleValue(() => 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 };

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

@@ -1,4 +0,0 @@
-import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".suggest-input-container{border-radius:2px;padding:2px 6px}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor-background,.suggest-input-container .mtk1{color:inherit}.suggest-input-container .suggest-input-placeholder{margin-top:1px;overflow:hidden;pointer-events:none;position:absolute;text-overflow:ellipsis;white-space:nowrap;z-index:1}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor .lines-content{background:none}";
-n(css,{});
-export { css, css as default };