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

package/vscode/src/vs/workbench/contrib/markers/browser/markersModel.js

@@ -1,200 +0,0 @@
-import { basename, extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { MarkerSeverity, IMarkerData } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
-import { flatten, isNonEmptyArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Hasher } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { splitLines } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { unsupportedSchemas } from 'monaco-editor/esm/vs/platform/markers/common/markerService.js';
-function compareMarkersByUri(a, b) {
-    return extUri.compare(a.resource, b.resource);
-}
-function compareResourceMarkers(a, b) {
-    const [firstMarkerOfA] = a.markers;
-    const [firstMarkerOfB] = b.markers;
-    let res = 0;
-    if (firstMarkerOfA && firstMarkerOfB) {
-        res = MarkerSeverity.compare(firstMarkerOfA.marker.severity, firstMarkerOfB.marker.severity);
-    }
-    if (res === 0) {
-        res = a.path.localeCompare(b.path) || a.name.localeCompare(b.name);
-    }
-    return res;
-}
-class ResourceMarkers {
-    constructor(id, resource) {
-        this.id = id;
-        this.resource = resource;
-        this._markersMap = ( new ResourceMap());
-        this._total = 0;
-        this.path = this.resource.fsPath;
-        this.name = basename(this.resource);
-    }
-    get markers() {
-        if (!this._cachedMarkers) {
-            this._cachedMarkers = flatten([...( this._markersMap.values())]).sort(ResourceMarkers._compareMarkers);
-        }
-        return this._cachedMarkers;
-    }
-    has(uri) {
-        return ( this._markersMap.has(uri));
-    }
-    set(uri, marker) {
-        this.delete(uri);
-        if (isNonEmptyArray(marker)) {
-            this._markersMap.set(uri, marker);
-            this._total += marker.length;
-            this._cachedMarkers = undefined;
-        }
-    }
-    delete(uri) {
-        const array = this._markersMap.get(uri);
-        if (array) {
-            this._total -= array.length;
-            this._cachedMarkers = undefined;
-            this._markersMap.delete(uri);
-        }
-    }
-    get total() {
-        return this._total;
-    }
-    static _compareMarkers(a, b) {
-        return MarkerSeverity.compare(a.marker.severity, b.marker.severity)
-            || extUri.compare(a.resource, b.resource)
-            || Range.compareRangesUsingStarts(a.marker, b.marker);
-    }
-}
-class Marker {
-    get resource() { return this.marker.resource; }
-    get range() { return this.marker; }
-    get lines() {
-        if (!this._lines) {
-            this._lines = splitLines(this.marker.message);
-        }
-        return this._lines;
-    }
-    constructor(id, marker, relatedInformation = []) {
-        this.id = id;
-        this.marker = marker;
-        this.relatedInformation = relatedInformation;
-    }
-    toString() {
-        return JSON.stringify({
-            ...this.marker,
-            resource: this.marker.resource.path,
-            relatedInformation: this.relatedInformation.length ? ( this.relatedInformation.map(r => ({ ...r.raw, resource: r.raw.resource.path }))) : undefined
-        }, null, '\t');
-    }
-}
-class MarkerTableItem extends Marker {
-    constructor(marker, sourceMatches, codeMatches, messageMatches, fileMatches, ownerMatches) {
-        super(marker.id, marker.marker, marker.relatedInformation);
-        this.sourceMatches = sourceMatches;
-        this.codeMatches = codeMatches;
-        this.messageMatches = messageMatches;
-        this.fileMatches = fileMatches;
-        this.ownerMatches = ownerMatches;
-    }
-}
-class RelatedInformation {
-    constructor(id, marker, raw) {
-        this.id = id;
-        this.marker = marker;
-        this.raw = raw;
-    }
-}
-class MarkersModel {
-    get resourceMarkers() {
-        if (!this.cachedSortedResources) {
-            this.cachedSortedResources = [...( this.resourcesByUri.values())].sort(compareResourceMarkers);
-        }
-        return this.cachedSortedResources;
-    }
-    constructor() {
-        this.cachedSortedResources = undefined;
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this._total = 0;
-        this.resourcesByUri = ( new Map());
-    }
-    reset() {
-        const removed = ( new Set());
-        for (const resourceMarker of ( this.resourcesByUri.values())) {
-            removed.add(resourceMarker);
-        }
-        this.resourcesByUri.clear();
-        this._total = 0;
-        this._onDidChange.fire({ removed, added: ( new Set()), updated: ( new Set()) });
-    }
-    get total() {
-        return this._total;
-    }
-    getResourceMarkers(resource) {
-        return this.resourcesByUri.get(extUri.getComparisonKey(resource, true)) ?? null;
-    }
-    setResourceMarkers(resourcesMarkers) {
-        const change = { added: ( new Set()), removed: ( new Set()), updated: ( new Set()) };
-        for (const [resource, rawMarkers] of resourcesMarkers) {
-            if (( unsupportedSchemas.has(resource.scheme))) {
-                continue;
-            }
-            const key = extUri.getComparisonKey(resource, true);
-            let resourceMarkers = this.resourcesByUri.get(key);
-            if (isNonEmptyArray(rawMarkers)) {
-                if (!resourceMarkers) {
-                    const resourceMarkersId = this.id(( resource.toString()));
-                    resourceMarkers = ( new ResourceMarkers(resourceMarkersId, resource.with({ fragment: null })));
-                    this.resourcesByUri.set(key, resourceMarkers);
-                    change.added.add(resourceMarkers);
-                }
-                else {
-                    change.updated.add(resourceMarkers);
-                }
-                const markersCountByKey = ( new Map());
-                const markers = ( rawMarkers.map((rawMarker) => {
-                    const key = IMarkerData.makeKey(rawMarker);
-                    const index = markersCountByKey.get(key) || 0;
-                    markersCountByKey.set(key, index + 1);
-                    const markerId = this.id(resourceMarkers.id, key, index, ( rawMarker.resource.toString()));
-                    let relatedInformation = undefined;
-                    if (rawMarker.relatedInformation) {
-                        relatedInformation = ( rawMarker.relatedInformation.map((r, index) => ( new RelatedInformation(this.id(markerId, ( r.resource.toString()), r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn, index), rawMarker, r))));
-                    }
-                    return ( new Marker(markerId, rawMarker, relatedInformation));
-                }));
-                this._total -= resourceMarkers.total;
-                resourceMarkers.set(resource, markers);
-                this._total += resourceMarkers.total;
-            }
-            else if (resourceMarkers) {
-                this._total -= resourceMarkers.total;
-                resourceMarkers.delete(resource);
-                this._total += resourceMarkers.total;
-                if (resourceMarkers.total === 0) {
-                    this.resourcesByUri.delete(key);
-                    change.removed.add(resourceMarkers);
-                }
-                else {
-                    change.updated.add(resourceMarkers);
-                }
-            }
-        }
-        this.cachedSortedResources = undefined;
-        if (change.added.size || change.removed.size || change.updated.size) {
-            this._onDidChange.fire(change);
-        }
-    }
-    id(...values) {
-        const hasher = ( new Hasher());
-        for (const value of values) {
-            hasher.hash(value);
-        }
-        return `${hasher.value}`;
-    }
-    dispose() {
-        this._onDidChange.dispose();
-        this.resourcesByUri.clear();
-    }
-}
-export { Marker, MarkerTableItem, MarkersModel, RelatedInformation, ResourceMarkers, compareMarkersByUri };

package/vscode/src/vs/workbench/contrib/markers/browser/markersTable.js

@@ -1,455 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { WorkbenchTable } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
-import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
-import { compareMarkersByUri, Marker, MarkerTableItem } from './markersModel.js';
-import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
-import { SeverityIcon } from 'monaco-editor/esm/vs/platform/severityIcon/browser/severityIcon.js';
-import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { FilterOptions } from './markersFilterOptions.js';
-import { Link } from 'monaco-editor/esm/vs/platform/opener/browser/link.js';
-import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
-import { QuickFixAction, QuickFixActionViewItem } from './markersViewActions.js';
-import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
-import Messages from './messages.js';
-import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { unsupportedSchemas } from 'monaco-editor/esm/vs/platform/markers/common/markerService.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-var MarkerSeverityColumnRenderer_1, MarkerCodeColumnRenderer_1, MarkerFileColumnRenderer_1;
-const $ = dom.$;
-let MarkerSeverityColumnRenderer = class MarkerSeverityColumnRenderer {
-    static { MarkerSeverityColumnRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'severity'; }
-    constructor(markersViewModel, instantiationService) {
-        this.markersViewModel = markersViewModel;
-        this.instantiationService = instantiationService;
-        this.templateId = MarkerSeverityColumnRenderer_1.TEMPLATE_ID;
-    }
-    renderTemplate(container) {
-        const severityColumn = dom.append(container, $('.severity'));
-        const icon = dom.append(severityColumn, $(''));
-        const actionBarColumn = dom.append(container, $('.actions'));
-        const actionBar = ( (new ActionBar(actionBarColumn, {
-            actionViewItemProvider: (action) => action.id === QuickFixAction.ID ? this.instantiationService.createInstance(QuickFixActionViewItem, action) : undefined,
-            animated: false
-        })));
-        return { actionBar, icon };
-    }
-    renderElement(element, index, templateData, height) {
-        const toggleQuickFix = (enabled) => {
-            if (!isUndefinedOrNull(enabled)) {
-                const container = dom.findParentWithClass(templateData.icon, 'monaco-table-td');
-                container.classList.toggle('quickFix', enabled);
-            }
-        };
-        templateData.icon.title = ( (MarkerSeverity.toString(element.marker.severity)));
-        templateData.icon.className = `marker-icon ${( ( Severity.toString(MarkerSeverity.toSeverity(element.marker.severity))))} codicon ${SeverityIcon.className(MarkerSeverity.toSeverity(element.marker.severity))}`;
-        templateData.actionBar.clear();
-        const viewModel = this.markersViewModel.getViewModel(element);
-        if (viewModel) {
-            const quickFixAction = viewModel.quickFixAction;
-            templateData.actionBar.push([quickFixAction], { icon: true, label: false });
-            toggleQuickFix(viewModel.quickFixAction.enabled);
-            quickFixAction.onDidChange(({ enabled }) => toggleQuickFix(enabled));
-            quickFixAction.onShowQuickFixes(() => {
-                const quickFixActionViewItem = templateData.actionBar.viewItems[0];
-                if (quickFixActionViewItem) {
-                    quickFixActionViewItem.showQuickFixes();
-                }
-            });
-        }
-    }
-    disposeTemplate(templateData) { }
-};
-MarkerSeverityColumnRenderer = MarkerSeverityColumnRenderer_1 = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], MarkerSeverityColumnRenderer)));
-let MarkerCodeColumnRenderer = class MarkerCodeColumnRenderer {
-    static { MarkerCodeColumnRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'code'; }
-    constructor(openerService) {
-        this.openerService = openerService;
-        this.templateId = MarkerCodeColumnRenderer_1.TEMPLATE_ID;
-    }
-    renderTemplate(container) {
-        const codeColumn = dom.append(container, $('.code'));
-        const sourceLabel = ( (new HighlightedLabel(codeColumn)));
-        sourceLabel.element.classList.add('source-label');
-        const codeLabel = ( (new HighlightedLabel(codeColumn)));
-        codeLabel.element.classList.add('code-label');
-        const codeLink = ( (new Link(codeColumn, { href: '', label: '' }, {}, this.openerService)));
-        return { codeColumn, sourceLabel, codeLabel, codeLink };
-    }
-    renderElement(element, index, templateData, height) {
-        templateData.codeColumn.classList.remove('code-label');
-        templateData.codeColumn.classList.remove('code-link');
-        if (element.marker.source && element.marker.code) {
-            if (typeof element.marker.code === 'string') {
-                templateData.codeColumn.classList.add('code-label');
-                templateData.codeColumn.title = `${element.marker.source} (${element.marker.code})`;
-                templateData.sourceLabel.set(element.marker.source, element.sourceMatches);
-                templateData.codeLabel.set(element.marker.code, element.codeMatches);
-            }
-            else {
-                templateData.codeColumn.classList.add('code-link');
-                templateData.codeColumn.title = `${element.marker.source} (${element.marker.code.value})`;
-                templateData.sourceLabel.set(element.marker.source, element.sourceMatches);
-                const codeLinkLabel = ( (new HighlightedLabel($('.code-link-label'))));
-                codeLinkLabel.set(element.marker.code.value, element.codeMatches);
-                templateData.codeLink.link = {
-                    href: ( (element.marker.code.target.toString())),
-                    title: ( (element.marker.code.target.toString())),
-                    label: codeLinkLabel.element,
-                };
-            }
-        }
-        else {
-            templateData.codeColumn.title = '';
-            templateData.sourceLabel.set('-');
-        }
-    }
-    disposeTemplate(templateData) { }
-};
-MarkerCodeColumnRenderer = MarkerCodeColumnRenderer_1 = ( (__decorate([
-    ( (__param(0, IOpenerService)))
-], MarkerCodeColumnRenderer)));
-class MarkerMessageColumnRenderer {
-    constructor() {
-        this.templateId = MarkerMessageColumnRenderer.TEMPLATE_ID;
-    }
-    static { this.TEMPLATE_ID = 'message'; }
-    renderTemplate(container) {
-        const columnElement = dom.append(container, $('.message'));
-        const highlightedLabel = ( (new HighlightedLabel(columnElement)));
-        return { columnElement, highlightedLabel };
-    }
-    renderElement(element, index, templateData, height) {
-        templateData.columnElement.title = element.marker.message;
-        templateData.highlightedLabel.set(element.marker.message, element.messageMatches);
-    }
-    disposeTemplate(templateData) { }
-}
-let MarkerFileColumnRenderer = class MarkerFileColumnRenderer {
-    static { MarkerFileColumnRenderer_1 = this; }
-    static { this.TEMPLATE_ID = 'file'; }
-    constructor(labelService) {
-        this.labelService = labelService;
-        this.templateId = MarkerFileColumnRenderer_1.TEMPLATE_ID;
-    }
-    renderTemplate(container) {
-        const columnElement = dom.append(container, $('.file'));
-        const fileLabel = ( (new HighlightedLabel(columnElement)));
-        fileLabel.element.classList.add('file-label');
-        const positionLabel = ( (new HighlightedLabel(columnElement)));
-        positionLabel.element.classList.add('file-position');
-        return { columnElement, fileLabel, positionLabel };
-    }
-    renderElement(element, index, templateData, height) {
-        const positionLabel = Messages.MARKERS_PANEL_AT_LINE_COL_NUMBER(element.marker.startLineNumber, element.marker.startColumn);
-        templateData.columnElement.title = `${this.labelService.getUriLabel(element.marker.resource, { relative: false })} ${positionLabel}`;
-        templateData.fileLabel.set(this.labelService.getUriLabel(element.marker.resource, { relative: true }), element.fileMatches);
-        templateData.positionLabel.set(positionLabel, undefined);
-    }
-    disposeTemplate(templateData) { }
-};
-MarkerFileColumnRenderer = MarkerFileColumnRenderer_1 = ( (__decorate([
-    ( (__param(0, ILabelService)))
-], MarkerFileColumnRenderer)));
-class MarkerOwnerColumnRenderer {
-    constructor() {
-        this.templateId = MarkerOwnerColumnRenderer.TEMPLATE_ID;
-    }
-    static { this.TEMPLATE_ID = 'owner'; }
-    renderTemplate(container) {
-        const columnElement = dom.append(container, $('.owner'));
-        const highlightedLabel = ( (new HighlightedLabel(columnElement)));
-        return { columnElement, highlightedLabel };
-    }
-    renderElement(element, index, templateData, height) {
-        templateData.columnElement.title = element.marker.owner;
-        templateData.highlightedLabel.set(element.marker.owner, element.ownerMatches);
-    }
-    disposeTemplate(templateData) { }
-}
-class MarkersTableVirtualDelegate {
-    constructor() {
-        this.headerRowHeight = MarkersTableVirtualDelegate.HEADER_ROW_HEIGHT;
-    }
-    static { this.HEADER_ROW_HEIGHT = 24; }
-    static { this.ROW_HEIGHT = 24; }
-    getHeight(item) {
-        return MarkersTableVirtualDelegate.ROW_HEIGHT;
-    }
-}
-let MarkersTable = class MarkersTable extends Disposable {
-    constructor(container, markersViewModel, resourceMarkers, filterOptions, options, instantiationService, labelService) {
-        super();
-        this.container = container;
-        this.markersViewModel = markersViewModel;
-        this.resourceMarkers = resourceMarkers;
-        this.filterOptions = filterOptions;
-        this.instantiationService = instantiationService;
-        this.labelService = labelService;
-        this._itemCount = 0;
-        this.table = this.instantiationService.createInstance(WorkbenchTable, 'Markers', this.container, ( (new MarkersTableVirtualDelegate())), [
-            {
-                label: '',
-                tooltip: '',
-                weight: 0,
-                minimumWidth: 36,
-                maximumWidth: 36,
-                templateId: MarkerSeverityColumnRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-            {
-                label: ( (localize('codeColumnLabel', "Code"))),
-                tooltip: '',
-                weight: 1,
-                minimumWidth: 100,
-                maximumWidth: 300,
-                templateId: MarkerCodeColumnRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-            {
-                label: ( (localize('messageColumnLabel', "Message"))),
-                tooltip: '',
-                weight: 4,
-                templateId: MarkerMessageColumnRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-            {
-                label: ( (localize('fileColumnLabel', "File"))),
-                tooltip: '',
-                weight: 2,
-                templateId: MarkerFileColumnRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            },
-            {
-                label: ( (localize('sourceColumnLabel', "Source"))),
-                tooltip: '',
-                weight: 1,
-                minimumWidth: 100,
-                maximumWidth: 300,
-                templateId: MarkerOwnerColumnRenderer.TEMPLATE_ID,
-                project(row) { return row; }
-            }
-        ], [
-            this.instantiationService.createInstance(MarkerSeverityColumnRenderer, this.markersViewModel),
-            this.instantiationService.createInstance(MarkerCodeColumnRenderer),
-            this.instantiationService.createInstance(MarkerMessageColumnRenderer),
-            this.instantiationService.createInstance(MarkerFileColumnRenderer),
-            this.instantiationService.createInstance(MarkerOwnerColumnRenderer),
-        ], options);
-        const list = this.table.domNode.querySelector('.monaco-list-rows');
-        const onRowHover = ( (( (Event.chain(this._register(( (new DomEmitter(list, 'mouseover')))).event)
-            .map(
-            e => dom.findParentWithClass(e.target, 'monaco-list-row', 'monaco-list-rows')
-        )))
-            .filter(((e) => !!e))
-            .map(e => parseInt(e.getAttribute('data-index')))))
-            .event;
-        const onListLeave = ( (Event.map(
-            this._register(( (new DomEmitter(list, 'mouseleave')))).event,
-            () => -1
-        )));
-        const onRowHoverOrLeave = Event.latch(Event.any(onRowHover, onListLeave));
-        const onRowPermanentHover = Event.debounce(onRowHoverOrLeave, (_, e) => e, 500);
-        this._register(onRowPermanentHover(e => {
-            if (e !== -1 && this.table.row(e)) {
-                this.markersViewModel.onMarkerMouseHover(this.table.row(e));
-            }
-        }));
-    }
-    get contextKeyService() {
-        return this.table.contextKeyService;
-    }
-    get onContextMenu() {
-        return this.table.onContextMenu;
-    }
-    get onDidOpen() {
-        return this.table.onDidOpen;
-    }
-    get onDidChangeFocus() {
-        return this.table.onDidChangeFocus;
-    }
-    get onDidChangeSelection() {
-        return this.table.onDidChangeSelection;
-    }
-    collapseMarkers() { }
-    domFocus() {
-        this.table.domFocus();
-    }
-    filterMarkers(resourceMarkers, filterOptions) {
-        this.filterOptions = filterOptions;
-        this.reset(resourceMarkers);
-    }
-    getFocus() {
-        const focus = this.table.getFocus();
-        return focus.length > 0 ? [...( (focus.map(f => this.table.row(f))))] : [];
-    }
-    getHTMLElement() {
-        return this.table.getHTMLElement();
-    }
-    getRelativeTop(marker) {
-        return marker ? this.table.getRelativeTop(this.table.indexOf(marker)) : null;
-    }
-    getSelection() {
-        const selection = this.table.getSelection();
-        return selection.length > 0 ? [...( (selection.map(i => this.table.row(i))))] : [];
-    }
-    getVisibleItemCount() {
-        return this._itemCount;
-    }
-    isVisible() {
-        return !this.container.classList.contains('hidden');
-    }
-    layout(height, width) {
-        this.container.style.height = `${height}px`;
-        this.table.layout(height, width);
-    }
-    reset(resourceMarkers) {
-        this.resourceMarkers = resourceMarkers;
-        const items = [];
-        for (const resourceMarker of this.resourceMarkers) {
-            for (const marker of resourceMarker.markers) {
-                if (( (unsupportedSchemas.has(marker.resource.scheme)))) {
-                    continue;
-                }
-                if (this.filterOptions.excludesMatcher.matches(marker.resource)) {
-                    continue;
-                }
-                if (this.filterOptions.includesMatcher.matches(marker.resource)) {
-                    items.push(( (new MarkerTableItem(marker))));
-                    continue;
-                }
-                const matchesSeverity = this.filterOptions.showErrors && MarkerSeverity.Error === marker.marker.severity ||
-                    this.filterOptions.showWarnings && MarkerSeverity.Warning === marker.marker.severity ||
-                    this.filterOptions.showInfos && MarkerSeverity.Info === marker.marker.severity;
-                if (!matchesSeverity) {
-                    continue;
-                }
-                if (this.filterOptions.textFilter.text) {
-                    const sourceMatches = marker.marker.source ? FilterOptions._filter(this.filterOptions.textFilter.text, marker.marker.source) ?? undefined : undefined;
-                    const codeMatches = marker.marker.code ? FilterOptions._filter(this.filterOptions.textFilter.text, typeof marker.marker.code === 'string' ? marker.marker.code : marker.marker.code.value) ?? undefined : undefined;
-                    const messageMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, marker.marker.message) ?? undefined;
-                    const fileMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, this.labelService.getUriLabel(marker.resource, { relative: true })) ?? undefined;
-                    const ownerMatches = FilterOptions._messageFilter(this.filterOptions.textFilter.text, marker.marker.owner) ?? undefined;
-                    const matched = sourceMatches || codeMatches || messageMatches || fileMatches || ownerMatches;
-                    if ((matched && !this.filterOptions.textFilter.negate) || (!matched && this.filterOptions.textFilter.negate)) {
-                        items.push(( (new MarkerTableItem(
-                            marker,
-                            sourceMatches,
-                            codeMatches,
-                            messageMatches,
-                            fileMatches,
-                            ownerMatches
-                        ))));
-                    }
-                    continue;
-                }
-                items.push(( (new MarkerTableItem(marker))));
-            }
-        }
-        this._itemCount = items.length;
-        this.table.splice(0, Number.POSITIVE_INFINITY, items.sort((a, b) => {
-            let result = MarkerSeverity.compare(a.marker.severity, b.marker.severity);
-            if (result === 0) {
-                result = compareMarkersByUri(a.marker, b.marker);
-            }
-            if (result === 0) {
-                result = Range.compareRangesUsingStarts(a.marker, b.marker);
-            }
-            return result;
-        }));
-    }
-    revealMarkers(activeResource, focus, lastSelectedRelativeTop) {
-        if (activeResource) {
-            const activeResourceIndex = this.resourceMarkers.indexOf(activeResource);
-            if (activeResourceIndex !== -1) {
-                if (this.hasSelectedMarkerFor(activeResource)) {
-                    const tableSelection = this.table.getSelection();
-                    this.table.reveal(tableSelection[0], lastSelectedRelativeTop);
-                    if (focus) {
-                        this.table.setFocus(tableSelection);
-                    }
-                }
-                else {
-                    this.table.reveal(activeResourceIndex, 0);
-                    if (focus) {
-                        this.table.setFocus([activeResourceIndex]);
-                        this.table.setSelection([activeResourceIndex]);
-                    }
-                }
-            }
-        }
-        else if (focus) {
-            this.table.setSelection([]);
-            this.table.focusFirst();
-        }
-    }
-    setAriaLabel(label) {
-        this.table.domNode.ariaLabel = label;
-    }
-    setMarkerSelection(selection, focus) {
-        if (this.isVisible()) {
-            if (selection && selection.length > 0) {
-                this.table.setSelection(( (selection.map(m => this.findMarkerIndex(m)))));
-                if (focus && focus.length > 0) {
-                    this.table.setFocus(( (focus.map(f => this.findMarkerIndex(f)))));
-                }
-                else {
-                    this.table.setFocus([this.findMarkerIndex(selection[0])]);
-                }
-                this.table.reveal(this.findMarkerIndex(selection[0]));
-            }
-            else if (this.getSelection().length === 0 && this.getVisibleItemCount() > 0) {
-                this.table.setSelection([0]);
-                this.table.setFocus([0]);
-                this.table.reveal(0);
-            }
-        }
-    }
-    toggleVisibility(hide) {
-        this.container.classList.toggle('hidden', hide);
-    }
-    update(resourceMarkers) {
-        for (const resourceMarker of resourceMarkers) {
-            const index = this.resourceMarkers.indexOf(resourceMarker);
-            this.resourceMarkers.splice(index, 1, resourceMarker);
-        }
-        this.reset(this.resourceMarkers);
-    }
-    updateMarker(marker) {
-        this.table.rerender();
-    }
-    findMarkerIndex(marker) {
-        for (let index = 0; index < this.table.length; index++) {
-            if (this.table.row(index).marker === marker.marker) {
-                return index;
-            }
-        }
-        return -1;
-    }
-    hasSelectedMarkerFor(resource) {
-        const selectedElement = this.getSelection();
-        if (selectedElement && selectedElement.length > 0) {
-            if (selectedElement[0] instanceof Marker) {
-                if (( (resource.has(selectedElement[0].marker.resource)))) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-};
-MarkersTable = ( (__decorate([
-    ( (__param(5, IInstantiationService))),
-    ( (__param(6, ILabelService)))
-], MarkersTable)));
-export { MarkersTable };