@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/contrib/gotoError/browser/gotoErrorWidget.js

@@ -0,0 +1,383 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { append, $, addStandardDisposableListener, clearNode } from '../../../../base/browser/dom.js';
+import { ScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { Color } from '../../../../base/common/color.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, dispose } from '../../../../base/common/lifecycle.js';
+import { basename } from '../../../../base/common/resources.js';
+import { splitLines } from '../../../../base/common/strings.js';
+import './media/gotoErrorWidget.css.js';
+import { Range } from '../../../common/core/range.js';
+import { PeekViewWidget, peekViewTitleForeground, peekViewTitleInfoForeground } from '../../peekView/browser/peekView.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuId, IMenuService } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { MarkerSeverity } from '../../../../platform/markers/common/markers.js';
+import { IOpenerService } from '../../../../platform/opener/common/opener.js';
+import { SeverityIcon } from '../../../../platform/severityIcon/browser/severityIcon.js';
+import { registerColor, contrastBorder, transparent, editorBackground, oneOf, editorErrorBorder, editorErrorForeground, editorWarningBorder, editorWarningForeground, editorInfoBorder, editorInfoForeground } from '../../../../platform/theme/common/colorRegistry.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+var MarkerNavigationWidget_1;
+class MessageWidget {
+    constructor(parent, editor, onRelatedInformation, _openerService, _labelService) {
+        this._openerService = _openerService;
+        this._labelService = _labelService;
+        this._lines = 0;
+        this._longestLineLength = 0;
+        this._relatedDiagnostics = ( new WeakMap());
+        this._disposables = ( new DisposableStore());
+        this._editor = editor;
+        const domNode = document.createElement('div');
+        domNode.className = 'descriptioncontainer';
+        this._messageBlock = document.createElement('div');
+        this._messageBlock.classList.add('message');
+        this._messageBlock.setAttribute('aria-live', 'assertive');
+        this._messageBlock.setAttribute('role', 'alert');
+        domNode.appendChild(this._messageBlock);
+        this._relatedBlock = document.createElement('div');
+        domNode.appendChild(this._relatedBlock);
+        this._disposables.add(addStandardDisposableListener(this._relatedBlock, 'click', event => {
+            event.preventDefault();
+            const related = this._relatedDiagnostics.get(event.target);
+            if (related) {
+                onRelatedInformation(related);
+            }
+        }));
+        this._scrollable = ( new ScrollableElement(domNode, {
+            horizontal: 1 ,
+            vertical: 1 ,
+            useShadows: false,
+            horizontalScrollbarSize: 6,
+            verticalScrollbarSize: 6
+        }));
+        parent.appendChild(this._scrollable.getDomNode());
+        this._disposables.add(this._scrollable.onScroll(e => {
+            domNode.style.left = `-${e.scrollLeft}px`;
+            domNode.style.top = `-${e.scrollTop}px`;
+        }));
+        this._disposables.add(this._scrollable);
+    }
+    dispose() {
+        dispose(this._disposables);
+    }
+    update(marker) {
+        const { source, message, relatedInformation, code } = marker;
+        let sourceAndCodeLength = (source?.length || 0) + '()'.length;
+        if (code) {
+            if (typeof code === 'string') {
+                sourceAndCodeLength += code.length;
+            }
+            else {
+                sourceAndCodeLength += code.value.length;
+            }
+        }
+        const lines = splitLines(message);
+        this._lines = lines.length;
+        this._longestLineLength = 0;
+        for (const line of lines) {
+            this._longestLineLength = Math.max(line.length + sourceAndCodeLength, this._longestLineLength);
+        }
+        clearNode(this._messageBlock);
+        this._messageBlock.setAttribute('aria-label', this.getAriaLabel(marker));
+        this._editor.applyFontInfo(this._messageBlock);
+        let lastLineElement = this._messageBlock;
+        for (const line of lines) {
+            lastLineElement = document.createElement('div');
+            lastLineElement.innerText = line;
+            if (line === '') {
+                lastLineElement.style.height = this._messageBlock.style.lineHeight;
+            }
+            this._messageBlock.appendChild(lastLineElement);
+        }
+        if (source || code) {
+            const detailsElement = document.createElement('span');
+            detailsElement.classList.add('details');
+            lastLineElement.appendChild(detailsElement);
+            if (source) {
+                const sourceElement = document.createElement('span');
+                sourceElement.innerText = source;
+                sourceElement.classList.add('source');
+                detailsElement.appendChild(sourceElement);
+            }
+            if (code) {
+                if (typeof code === 'string') {
+                    const codeElement = document.createElement('span');
+                    codeElement.innerText = `(${code})`;
+                    codeElement.classList.add('code');
+                    detailsElement.appendChild(codeElement);
+                }
+                else {
+                    this._codeLink = $('a.code-link');
+                    this._codeLink.setAttribute('href', `${( code.target.toString())}`);
+                    this._codeLink.onclick = (e) => {
+                        this._openerService.open(code.target, { allowCommands: true });
+                        e.preventDefault();
+                        e.stopPropagation();
+                    };
+                    const codeElement = append(this._codeLink, $('span'));
+                    codeElement.innerText = code.value;
+                    detailsElement.appendChild(this._codeLink);
+                }
+            }
+        }
+        clearNode(this._relatedBlock);
+        this._editor.applyFontInfo(this._relatedBlock);
+        if (isNonEmptyArray(relatedInformation)) {
+            const relatedInformationNode = this._relatedBlock.appendChild(document.createElement('div'));
+            relatedInformationNode.style.paddingTop = `${Math.floor(this._editor.getOption(66 ) * 0.66)}px`;
+            this._lines += 1;
+            for (const related of relatedInformation) {
+                const container = document.createElement('div');
+                const relatedResource = document.createElement('a');
+                relatedResource.classList.add('filename');
+                relatedResource.innerText = `${this._labelService.getUriBasenameLabel(related.resource)}(${related.startLineNumber}, ${related.startColumn}): `;
+                relatedResource.title = this._labelService.getUriLabel(related.resource);
+                this._relatedDiagnostics.set(relatedResource, related);
+                const relatedMessage = document.createElement('span');
+                relatedMessage.innerText = related.message;
+                container.appendChild(relatedResource);
+                container.appendChild(relatedMessage);
+                this._lines += 1;
+                relatedInformationNode.appendChild(container);
+            }
+        }
+        const fontInfo = this._editor.getOption(50 );
+        const scrollWidth = Math.ceil(fontInfo.typicalFullwidthCharacterWidth * this._longestLineLength * 0.75);
+        const scrollHeight = fontInfo.lineHeight * this._lines;
+        this._scrollable.setScrollDimensions({ scrollWidth, scrollHeight });
+    }
+    layout(height, width) {
+        this._scrollable.getDomNode().style.height = `${height}px`;
+        this._scrollable.getDomNode().style.width = `${width}px`;
+        this._scrollable.setScrollDimensions({ width, height });
+    }
+    getHeightInLines() {
+        return Math.min(17, this._lines);
+    }
+    getAriaLabel(marker) {
+        let severityLabel = '';
+        switch (marker.severity) {
+            case MarkerSeverity.Error:
+                severityLabel = ( localizeWithPath('vs/editor/contrib/gotoError/browser/gotoErrorWidget', 'Error', "Error"));
+                break;
+            case MarkerSeverity.Warning:
+                severityLabel = ( localizeWithPath(
+                    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+                    'Warning',
+                    "Warning"
+                ));
+                break;
+            case MarkerSeverity.Info:
+                severityLabel = ( localizeWithPath('vs/editor/contrib/gotoError/browser/gotoErrorWidget', 'Info', "Info"));
+                break;
+            case MarkerSeverity.Hint:
+                severityLabel = ( localizeWithPath('vs/editor/contrib/gotoError/browser/gotoErrorWidget', 'Hint', "Hint"));
+                break;
+        }
+        let ariaLabel = ( localizeWithPath(
+            'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+            'marker aria',
+            "{0} at {1}. ",
+            severityLabel,
+            marker.startLineNumber + ':' + marker.startColumn
+        ));
+        const model = this._editor.getModel();
+        if (model && (marker.startLineNumber <= model.getLineCount()) && (marker.startLineNumber >= 1)) {
+            const lineContent = model.getLineContent(marker.startLineNumber);
+            ariaLabel = `${lineContent}, ${ariaLabel}`;
+        }
+        return ariaLabel;
+    }
+}
+let MarkerNavigationWidget = class MarkerNavigationWidget extends PeekViewWidget {
+    static { MarkerNavigationWidget_1 = this; }
+    static { this.TitleMenu = ( new MenuId('gotoErrorTitleMenu')); }
+    constructor(editor, _themeService, _openerService, _menuService, instantiationService, _contextKeyService, _labelService) {
+        super(editor, { showArrow: true, showFrame: true, isAccessible: true, frameWidth: 1 }, instantiationService);
+        this._themeService = _themeService;
+        this._openerService = _openerService;
+        this._menuService = _menuService;
+        this._contextKeyService = _contextKeyService;
+        this._labelService = _labelService;
+        this._callOnDispose = ( new DisposableStore());
+        this._onDidSelectRelatedInformation = ( new Emitter());
+        this.onDidSelectRelatedInformation = this._onDidSelectRelatedInformation.event;
+        this._severity = MarkerSeverity.Warning;
+        this._backgroundColor = Color.white;
+        this._applyTheme(_themeService.getColorTheme());
+        this._callOnDispose.add(_themeService.onDidColorThemeChange(this._applyTheme.bind(this)));
+        this.create();
+    }
+    _applyTheme(theme) {
+        this._backgroundColor = theme.getColor(editorMarkerNavigationBackground);
+        let colorId = editorMarkerNavigationError;
+        let headerBackground = editorMarkerNavigationErrorHeader;
+        if (this._severity === MarkerSeverity.Warning) {
+            colorId = editorMarkerNavigationWarning;
+            headerBackground = editorMarkerNavigationWarningHeader;
+        }
+        else if (this._severity === MarkerSeverity.Info) {
+            colorId = editorMarkerNavigationInfo;
+            headerBackground = editorMarkerNavigationInfoHeader;
+        }
+        const frameColor = theme.getColor(colorId);
+        const headerBg = theme.getColor(headerBackground);
+        this.style({
+            arrowColor: frameColor,
+            frameColor: frameColor,
+            headerBackgroundColor: headerBg,
+            primaryHeadingColor: theme.getColor(peekViewTitleForeground),
+            secondaryHeadingColor: theme.getColor(peekViewTitleInfoForeground)
+        });
+    }
+    _applyStyles() {
+        if (this._parentContainer) {
+            this._parentContainer.style.backgroundColor = this._backgroundColor ? ( this._backgroundColor.toString()) : '';
+        }
+        super._applyStyles();
+    }
+    dispose() {
+        this._callOnDispose.dispose();
+        super.dispose();
+    }
+    focus() {
+        this._parentContainer.focus();
+    }
+    _fillHead(container) {
+        super._fillHead(container);
+        this._disposables.add(this._actionbarWidget.actionRunner.onWillRun(e => this.editor.focus()));
+        const actions = [];
+        const menu = this._menuService.createMenu(MarkerNavigationWidget_1.TitleMenu, this._contextKeyService);
+        createAndFillInActionBarActions(menu, undefined, actions);
+        this._actionbarWidget.push(actions, { label: false, icon: true, index: 0 });
+        menu.dispose();
+    }
+    _fillTitleIcon(container) {
+        this._icon = append(container, $(''));
+    }
+    _fillBody(container) {
+        this._parentContainer = container;
+        container.classList.add('marker-widget');
+        this._parentContainer.tabIndex = 0;
+        this._parentContainer.setAttribute('role', 'tooltip');
+        this._container = document.createElement('div');
+        container.appendChild(this._container);
+        this._message = ( new MessageWidget(
+            this._container,
+            this.editor,
+            related => this._onDidSelectRelatedInformation.fire(related),
+            this._openerService,
+            this._labelService
+        ));
+        this._disposables.add(this._message);
+    }
+    show() {
+        throw new Error('call showAtMarker');
+    }
+    showAtMarker(marker, markerIdx, markerCount) {
+        this._container.classList.remove('stale');
+        this._message.update(marker);
+        this._severity = marker.severity;
+        this._applyTheme(this._themeService.getColorTheme());
+        const range = Range.lift(marker);
+        const editorPosition = this.editor.getPosition();
+        const position = editorPosition && range.containsPosition(editorPosition) ? editorPosition : range.getStartPosition();
+        super.show(position, this.computeRequiredHeight());
+        const model = this.editor.getModel();
+        if (model) {
+            const detail = markerCount > 1
+                ? ( localizeWithPath(
+                'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+                'problems',
+                "{0} of {1} problems",
+                markerIdx,
+                markerCount
+            ))
+                : ( localizeWithPath(
+                'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+                'change',
+                "{0} of {1} problem",
+                markerIdx,
+                markerCount
+            ));
+            this.setTitle(basename(model.uri), detail);
+        }
+        this._icon.className = `codicon ${SeverityIcon.className(MarkerSeverity.toSeverity(this._severity))}`;
+        this.editor.revealPositionNearTop(position, 0 );
+        this.editor.focus();
+    }
+    updateMarker(marker) {
+        this._container.classList.remove('stale');
+        this._message.update(marker);
+    }
+    showStale() {
+        this._container.classList.add('stale');
+        this._relayout();
+    }
+    _doLayoutBody(heightInPixel, widthInPixel) {
+        super._doLayoutBody(heightInPixel, widthInPixel);
+        this._heightInPixel = heightInPixel;
+        this._message.layout(heightInPixel, widthInPixel);
+        this._container.style.height = `${heightInPixel}px`;
+    }
+    _onWidth(widthInPixel) {
+        this._message.layout(this._heightInPixel, widthInPixel);
+    }
+    _relayout() {
+        super._relayout(this.computeRequiredHeight());
+    }
+    computeRequiredHeight() {
+        return 3 + this._message.getHeightInLines();
+    }
+};
+MarkerNavigationWidget = MarkerNavigationWidget_1 = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, ILabelService))
+], MarkerNavigationWidget));
+const errorDefault = oneOf(editorErrorForeground, editorErrorBorder);
+const warningDefault = oneOf(editorWarningForeground, editorWarningBorder);
+const infoDefault = oneOf(editorInfoForeground, editorInfoBorder);
+const editorMarkerNavigationError = registerColor('editorMarkerNavigationError.background', { dark: errorDefault, light: errorDefault, hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationError',
+    'Editor marker navigation widget error color.'
+)));
+const editorMarkerNavigationErrorHeader = registerColor('editorMarkerNavigationError.headerBackground', { dark: ( transparent(editorMarkerNavigationError, .1)), light: ( transparent(editorMarkerNavigationError, .1)), hcDark: null, hcLight: null }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationErrorHeaderBackground',
+    'Editor marker navigation widget error heading background.'
+)));
+const editorMarkerNavigationWarning = registerColor('editorMarkerNavigationWarning.background', { dark: warningDefault, light: warningDefault, hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationWarning',
+    'Editor marker navigation widget warning color.'
+)));
+const editorMarkerNavigationWarningHeader = registerColor('editorMarkerNavigationWarning.headerBackground', { dark: ( transparent(editorMarkerNavigationWarning, .1)), light: ( transparent(editorMarkerNavigationWarning, .1)), hcDark: '#0C141F', hcLight: ( transparent(editorMarkerNavigationWarning, .2)) }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationWarningBackground',
+    'Editor marker navigation widget warning heading background.'
+)));
+const editorMarkerNavigationInfo = registerColor('editorMarkerNavigationInfo.background', { dark: infoDefault, light: infoDefault, hcDark: contrastBorder, hcLight: contrastBorder }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationInfo',
+    'Editor marker navigation widget info color.'
+)));
+const editorMarkerNavigationInfoHeader = registerColor('editorMarkerNavigationInfo.headerBackground', { dark: ( transparent(editorMarkerNavigationInfo, .1)), light: ( transparent(editorMarkerNavigationInfo, .1)), hcDark: null, hcLight: null }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationInfoHeaderBackground',
+    'Editor marker navigation widget info heading background.'
+)));
+const editorMarkerNavigationBackground = registerColor('editorMarkerNavigation.background', { dark: editorBackground, light: editorBackground, hcDark: editorBackground, hcLight: editorBackground }, ( localizeWithPath(
+    'vs/editor/contrib/gotoError/browser/gotoErrorWidget',
+    'editorMarkerNavigationBackground',
+    'Editor marker navigation widget background.'
+)));
+export { MarkerNavigationWidget };

package/vscode/src/vs/editor/contrib/gotoError/browser/markerNavigationService.js

@@ -0,0 +1,187 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { binarySearch } from '../../../../base/common/arrays.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../../base/common/linkedList.js';
+import { compare } from '../../../../base/common/strings.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Range } from '../../../common/core/range.js';
+import { registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IMarkerService, MarkerSeverity } from '../../../../platform/markers/common/markers.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+class MarkerCoordinate {
+    constructor(marker, index, total) {
+        this.marker = marker;
+        this.index = index;
+        this.total = total;
+    }
+}
+let MarkerList = class MarkerList {
+    constructor(resourceFilter, _markerService, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._dispoables = ( new DisposableStore());
+        this._markers = [];
+        this._nextIdx = -1;
+        if (URI.isUri(resourceFilter)) {
+            this._resourceFilter = uri => ( uri.toString()) === ( resourceFilter.toString());
+        }
+        else if (resourceFilter) {
+            this._resourceFilter = resourceFilter;
+        }
+        const compareOrder = this._configService.getValue('problems.sortOrder');
+        const compareMarker = (a, b) => {
+            let res = compare(( a.resource.toString()), ( b.resource.toString()));
+            if (res === 0) {
+                if (compareOrder === 'position') {
+                    res = Range.compareRangesUsingStarts(a, b) || MarkerSeverity.compare(a.severity, b.severity);
+                }
+                else {
+                    res = MarkerSeverity.compare(a.severity, b.severity) || Range.compareRangesUsingStarts(a, b);
+                }
+            }
+            return res;
+        };
+        const updateMarker = () => {
+            this._markers = this._markerService.read({
+                resource: URI.isUri(resourceFilter) ? resourceFilter : undefined,
+                severities: MarkerSeverity.Error | MarkerSeverity.Warning | MarkerSeverity.Info
+            });
+            if (typeof resourceFilter === 'function') {
+                this._markers = this._markers.filter(m => this._resourceFilter(m.resource));
+            }
+            this._markers.sort(compareMarker);
+        };
+        updateMarker();
+        this._dispoables.add(_markerService.onMarkerChanged(uris => {
+            if (!this._resourceFilter || ( uris.some(uri => this._resourceFilter(uri)))) {
+                updateMarker();
+                this._nextIdx = -1;
+                this._onDidChange.fire();
+            }
+        }));
+    }
+    dispose() {
+        this._dispoables.dispose();
+        this._onDidChange.dispose();
+    }
+    matches(uri) {
+        if (!this._resourceFilter && !uri) {
+            return true;
+        }
+        if (!this._resourceFilter || !uri) {
+            return false;
+        }
+        return this._resourceFilter(uri);
+    }
+    get selected() {
+        const marker = this._markers[this._nextIdx];
+        return marker && ( new MarkerCoordinate(marker, this._nextIdx + 1, this._markers.length));
+    }
+    _initIdx(model, position, fwd) {
+        let found = false;
+        let idx = this._markers.findIndex(marker => ( marker.resource.toString()) === ( model.uri.toString()));
+        if (idx < 0) {
+            idx = binarySearch(this._markers, { resource: model.uri }, (a, b) => compare(( a.resource.toString()), ( b.resource.toString())));
+            if (idx < 0) {
+                idx = ~idx;
+            }
+        }
+        for (let i = idx; i < this._markers.length; i++) {
+            let range = Range.lift(this._markers[i]);
+            if (range.isEmpty()) {
+                const word = model.getWordAtPosition(range.getStartPosition());
+                if (word) {
+                    range = ( new Range(
+                        range.startLineNumber,
+                        word.startColumn,
+                        range.startLineNumber,
+                        word.endColumn
+                    ));
+                }
+            }
+            if (position && (range.containsPosition(position) || position.isBeforeOrEqual(range.getStartPosition()))) {
+                this._nextIdx = i;
+                found = true;
+                break;
+            }
+            if (( this._markers[i].resource.toString()) !== ( model.uri.toString())) {
+                break;
+            }
+        }
+        if (!found) {
+            this._nextIdx = fwd ? 0 : this._markers.length - 1;
+        }
+        if (this._nextIdx < 0) {
+            this._nextIdx = this._markers.length - 1;
+        }
+    }
+    resetIndex() {
+        this._nextIdx = -1;
+    }
+    move(fwd, model, position) {
+        if (this._markers.length === 0) {
+            return false;
+        }
+        const oldIdx = this._nextIdx;
+        if (this._nextIdx === -1) {
+            this._initIdx(model, position, fwd);
+        }
+        else if (fwd) {
+            this._nextIdx = (this._nextIdx + 1) % this._markers.length;
+        }
+        else if (!fwd) {
+            this._nextIdx = (this._nextIdx - 1 + this._markers.length) % this._markers.length;
+        }
+        if (oldIdx !== this._nextIdx) {
+            return true;
+        }
+        return false;
+    }
+    find(uri, position) {
+        let idx = this._markers.findIndex(marker => ( marker.resource.toString()) === ( uri.toString()));
+        if (idx < 0) {
+            return undefined;
+        }
+        for (; idx < this._markers.length; idx++) {
+            if (Range.containsPosition(this._markers[idx], position)) {
+                return ( new MarkerCoordinate(this._markers[idx], idx + 1, this._markers.length));
+            }
+        }
+        return undefined;
+    }
+};
+MarkerList = ( __decorate([
+    ( __param(1, IMarkerService)),
+    ( __param(2, IConfigurationService))
+], MarkerList));
+const IMarkerNavigationService = ( createDecorator('IMarkerNavigationService'));
+let MarkerNavigationService = class MarkerNavigationService {
+    constructor(_markerService, _configService) {
+        this._markerService = _markerService;
+        this._configService = _configService;
+        this._provider = ( new LinkedList());
+    }
+    registerProvider(provider) {
+        const remove = this._provider.unshift(provider);
+        return toDisposable(() => remove());
+    }
+    getMarkerList(resource) {
+        for (const provider of this._provider) {
+            const result = provider.getMarkerList(resource);
+            if (result) {
+                return result;
+            }
+        }
+        return ( new MarkerList(resource, this._markerService, this._configService));
+    }
+};
+MarkerNavigationService = ( __decorate([
+    ( __param(0, IMarkerService)),
+    ( __param(1, IConfigurationService))
+], MarkerNavigationService));
+registerSingleton(IMarkerNavigationService, MarkerNavigationService, 1 );
+export { IMarkerNavigationService, MarkerCoordinate, MarkerList };

package/vscode/src/vs/editor/contrib/gotoError/browser/media/gotoErrorWidget.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .peekview-widget .head .peekview-title .severity-icon{display:inline-block;margin-right:4px;vertical-align:text-top}.monaco-editor .marker-widget{text-overflow:ellipsis;white-space:nowrap}.monaco-editor .marker-widget>.stale{font-style:italic;opacity:.6}.monaco-editor .marker-widget .title{display:inline-block;padding-right:5px}.monaco-editor .marker-widget .descriptioncontainer{padding:8px 12px 0 20px;position:absolute;user-select:text;-webkit-user-select:text;white-space:pre}.monaco-editor .marker-widget .descriptioncontainer .message{display:flex;flex-direction:column}.monaco-editor .marker-widget .descriptioncontainer .message .details{padding-left:6px}.monaco-editor .marker-widget .descriptioncontainer .message .source,.monaco-editor .marker-widget .descriptioncontainer .message span.code{opacity:.6}.monaco-editor .marker-widget .descriptioncontainer .message a.code-link{color:inherit;opacity:.6}.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:before{content:\"(\"}.monaco-editor .marker-widget .descriptioncontainer .message a.code-link:after{content:\")\"}.monaco-editor .marker-widget .descriptioncontainer .message a.code-link>span{border-bottom:1px solid transparent;color:var(--vscode-textLink-foreground);color:var(--vscode-textLink-activeForeground);text-decoration:underline;text-underline-position:under}.monaco-editor .marker-widget .descriptioncontainer .filename{cursor:pointer}";
+n(css,{});
+export { css, css as default };