monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/goToDefinitionAtPosition.js

@@ -0,0 +1,267 @@
+import { createCancelablePromise } from '../../../../../base/common/async.js';
+import { onUnexpectedError } from '../../../../../base/common/errors.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import './goToDefinitionAtPosition.css';
+import { EditorState } from '../../../editorState/browser/editorState.js';
+import { registerEditorContribution } from '../../../../browser/editorExtensions.js';
+import { Range } from '../../../../common/core/range.js';
+import { ILanguageService } from '../../../../common/languages/language.js';
+import { ITextModelService } from '../../../../common/services/resolverService.js';
+import { ClickLinkGesture } from './clickLinkGesture.js';
+import { PeekContext } from '../../../peekView/browser/peekView.js';
+import { localize } from '../../../../../nls.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { DefinitionAction } from '../goToCommands.js';
+import { getDefinitionsAtPosition } from '../goToSymbol.js';
+import { ILanguageFeaturesService } from '../../../../common/services/languageFeatures.js';
+import { ModelDecorationInjectedTextOptions } from '../../../../common/model/textModel.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var GotoDefinitionAtPositionEditorContribution_1;
+let GotoDefinitionAtPositionEditorContribution = class GotoDefinitionAtPositionEditorContribution {
+    static { GotoDefinitionAtPositionEditorContribution_1 = this; }
+    static { this.ID = 'editor.contrib.gotodefinitionatposition'; }
+    static { this.MAX_SOURCE_PREVIEW_LINES = 8; }
+    constructor(editor, textModelResolverService, languageService, languageFeaturesService) {
+        this.textModelResolverService = textModelResolverService;
+        this.languageService = languageService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.toUnhook = new DisposableStore();
+        this.toUnhookForKeyboard = new DisposableStore();
+        this.currentWordAtPosition = null;
+        this.previousPromise = null;
+        this.editor = editor;
+        this.linkDecorations = this.editor.createDecorationsCollection();
+        const linkGesture = new ClickLinkGesture(editor);
+        this.toUnhook.add(linkGesture);
+        this.toUnhook.add(linkGesture.onMouseMoveOrRelevantKeyDown(([mouseEvent, keyboardEvent]) => {
+            this.startFindDefinitionFromMouse(mouseEvent, keyboardEvent ?? undefined);
+        }));
+        this.toUnhook.add(linkGesture.onExecute((mouseEvent) => {
+            if (this.isEnabled(mouseEvent)) {
+                this.gotoDefinition(mouseEvent.target.position, mouseEvent.hasSideBySideModifier)
+                    .catch((error) => {
+                    onUnexpectedError(error);
+                })
+                    .finally(() => {
+                    this.removeLinkDecorations();
+                });
+            }
+        }));
+        this.toUnhook.add(linkGesture.onCancel(() => {
+            this.removeLinkDecorations();
+            this.currentWordAtPosition = null;
+        }));
+    }
+    static get(editor) {
+        return editor.getContribution(GotoDefinitionAtPositionEditorContribution_1.ID);
+    }
+    async startFindDefinitionFromCursor(position) {
+        // For issue: https://github.com/microsoft/vscode/issues/46257
+        // equivalent to mouse move with meta/ctrl key
+        // First find the definition and add decorations
+        // to the editor to be shown with the content hover widget
+        await this.startFindDefinition(position);
+        // Add listeners for editor cursor move and key down events
+        // Dismiss the "extended" editor decorations when the user hides
+        // the hover widget. There is no event for the widget itself so these
+        // serve as a best effort. After removing the link decorations, the hover
+        // widget is clean and will only show declarations per next request.
+        this.toUnhookForKeyboard.add(this.editor.onDidChangeCursorPosition(() => {
+            this.currentWordAtPosition = null;
+            this.removeLinkDecorations();
+            this.toUnhookForKeyboard.clear();
+        }));
+        this.toUnhookForKeyboard.add(this.editor.onKeyDown((e) => {
+            if (e) {
+                this.currentWordAtPosition = null;
+                this.removeLinkDecorations();
+                this.toUnhookForKeyboard.clear();
+            }
+        }));
+    }
+    startFindDefinitionFromMouse(mouseEvent, withKey) {
+        // check if we are active and on a content widget
+        if (mouseEvent.target.type === 9 /* MouseTargetType.CONTENT_WIDGET */ && this.linkDecorations.length > 0) {
+            return;
+        }
+        if (!this.editor.hasModel() || !this.isEnabled(mouseEvent, withKey)) {
+            this.currentWordAtPosition = null;
+            this.removeLinkDecorations();
+            return;
+        }
+        const position = mouseEvent.target.position;
+        this.startFindDefinition(position);
+    }
+    async startFindDefinition(position) {
+        // Dispose listeners for updating decorations when using keyboard to show definition hover
+        this.toUnhookForKeyboard.clear();
+        // Find word at mouse position
+        const word = position ? this.editor.getModel()?.getWordAtPosition(position) : null;
+        if (!word) {
+            this.currentWordAtPosition = null;
+            this.removeLinkDecorations();
+            return;
+        }
+        // Return early if word at position is still the same
+        if (this.currentWordAtPosition && this.currentWordAtPosition.startColumn === word.startColumn && this.currentWordAtPosition.endColumn === word.endColumn && this.currentWordAtPosition.word === word.word) {
+            return;
+        }
+        this.currentWordAtPosition = word;
+        // Find definition and decorate word if found
+        const state = new EditorState(this.editor, 4 /* CodeEditorStateFlag.Position */ | 1 /* CodeEditorStateFlag.Value */ | 2 /* CodeEditorStateFlag.Selection */ | 8 /* CodeEditorStateFlag.Scroll */);
+        if (this.previousPromise) {
+            this.previousPromise.cancel();
+            this.previousPromise = null;
+        }
+        this.previousPromise = createCancelablePromise(token => this.findDefinition(position, token));
+        let results;
+        try {
+            results = await this.previousPromise;
+        }
+        catch (error) {
+            onUnexpectedError(error);
+            return;
+        }
+        if (!results || !results.length || !state.validate(this.editor)) {
+            this.removeLinkDecorations();
+            return;
+        }
+        const linkRange = results[0].originSelectionRange
+            ? Range.lift(results[0].originSelectionRange)
+            : new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+        // Multiple results
+        if (results.length > 1) {
+            let combinedRange = linkRange;
+            for (const { originSelectionRange } of results) {
+                if (originSelectionRange) {
+                    combinedRange = Range.plusRange(combinedRange, originSelectionRange);
+                }
+            }
+            this.addDecoration(combinedRange, new MarkdownString().appendText(localize(1077, "Click to show {0} definitions.", results.length)));
+        }
+        else {
+            // Single result
+            const result = results[0];
+            if (!result.uri) {
+                return;
+            }
+            return this.textModelResolverService.createModelReference(result.uri).then(ref => {
+                if (!ref.object || !ref.object.textEditorModel) {
+                    ref.dispose();
+                    return;
+                }
+                const { object: { textEditorModel } } = ref;
+                const { startLineNumber } = result.range;
+                if (startLineNumber < 1 || startLineNumber > textEditorModel.getLineCount()) {
+                    // invalid range
+                    ref.dispose();
+                    return;
+                }
+                const previewValue = this.getPreviewValue(textEditorModel, startLineNumber, result);
+                const languageId = this.languageService.guessLanguageIdByFilepathOrFirstLine(textEditorModel.uri);
+                this.addDecoration(linkRange, previewValue ? new MarkdownString().appendCodeblock(languageId ? languageId : '', previewValue) : undefined);
+                ref.dispose();
+            });
+        }
+    }
+    getPreviewValue(textEditorModel, startLineNumber, result) {
+        let rangeToUse = result.range;
+        const numberOfLinesInRange = rangeToUse.endLineNumber - rangeToUse.startLineNumber;
+        if (numberOfLinesInRange >= GotoDefinitionAtPositionEditorContribution_1.MAX_SOURCE_PREVIEW_LINES) {
+            rangeToUse = this.getPreviewRangeBasedOnIndentation(textEditorModel, startLineNumber);
+        }
+        rangeToUse = textEditorModel.validateRange(rangeToUse);
+        const previewValue = this.stripIndentationFromPreviewRange(textEditorModel, startLineNumber, rangeToUse);
+        return previewValue;
+    }
+    stripIndentationFromPreviewRange(textEditorModel, startLineNumber, previewRange) {
+        const startIndent = textEditorModel.getLineFirstNonWhitespaceColumn(startLineNumber);
+        let minIndent = startIndent;
+        for (let endLineNumber = startLineNumber + 1; endLineNumber < previewRange.endLineNumber; endLineNumber++) {
+            const endIndent = textEditorModel.getLineFirstNonWhitespaceColumn(endLineNumber);
+            minIndent = Math.min(minIndent, endIndent);
+        }
+        const previewValue = textEditorModel.getValueInRange(previewRange).replace(new RegExp(`^\\s{${minIndent - 1}}`, 'gm'), '').trim();
+        return previewValue;
+    }
+    getPreviewRangeBasedOnIndentation(textEditorModel, startLineNumber) {
+        const startIndent = textEditorModel.getLineFirstNonWhitespaceColumn(startLineNumber);
+        const maxLineNumber = Math.min(textEditorModel.getLineCount(), startLineNumber + GotoDefinitionAtPositionEditorContribution_1.MAX_SOURCE_PREVIEW_LINES);
+        let endLineNumber = startLineNumber + 1;
+        for (; endLineNumber < maxLineNumber; endLineNumber++) {
+            const endIndent = textEditorModel.getLineFirstNonWhitespaceColumn(endLineNumber);
+            if (startIndent === endIndent) {
+                break;
+            }
+        }
+        return new Range(startLineNumber, 1, endLineNumber + 1, 1);
+    }
+    addDecoration(range, hoverMessage) {
+        const newDecorations = {
+            range: range,
+            options: {
+                description: 'goto-definition-link',
+                inlineClassName: 'goto-definition-link',
+                hoverMessage
+            }
+        };
+        this.linkDecorations.set([newDecorations]);
+    }
+    removeLinkDecorations() {
+        this.linkDecorations.clear();
+    }
+    isEnabled(mouseEvent, withKey) {
+        return this.editor.hasModel()
+            && mouseEvent.isLeftClick
+            && mouseEvent.isNoneOrSingleMouseDown
+            && mouseEvent.target.type === 6 /* MouseTargetType.CONTENT_TEXT */
+            && !(mouseEvent.target.detail.injectedText?.options instanceof ModelDecorationInjectedTextOptions)
+            && (mouseEvent.hasTriggerModifier || (withKey ? withKey.keyCodeIsTriggerKey : false))
+            && this.languageFeaturesService.definitionProvider.has(this.editor.getModel());
+    }
+    findDefinition(position, token) {
+        const model = this.editor.getModel();
+        if (!model) {
+            return Promise.resolve(null);
+        }
+        return getDefinitionsAtPosition(this.languageFeaturesService.definitionProvider, model, position, false, token);
+    }
+    async gotoDefinition(position, openToSide) {
+        this.editor.setPosition(position);
+        return this.editor.invokeWithinContext((accessor) => {
+            const canPeek = !openToSide && this.editor.getOption(101 /* EditorOption.definitionLinkOpensInPeek */) && !this.isInPeekEditor(accessor);
+            const action = new DefinitionAction({ openToSide, openInPeek: canPeek, muteMessage: true }, { title: { value: '', original: '' }, id: '', precondition: undefined });
+            return action.run(accessor);
+        });
+    }
+    isInPeekEditor(accessor) {
+        const contextKeyService = accessor.get(IContextKeyService);
+        return PeekContext.inPeekEditor.getValue(contextKeyService);
+    }
+    dispose() {
+        this.toUnhook.dispose();
+        this.toUnhookForKeyboard.dispose();
+    }
+};
+GotoDefinitionAtPositionEditorContribution = GotoDefinitionAtPositionEditorContribution_1 = __decorate([
+    __param(1, ITextModelService),
+    __param(2, ILanguageService),
+    __param(3, ILanguageFeaturesService)
+], GotoDefinitionAtPositionEditorContribution);
+registerEditorContribution(GotoDefinitionAtPositionEditorContribution.ID, GotoDefinitionAtPositionEditorContribution, 2 /* EditorContributionInstantiation.BeforeFirstInteraction */);
+
+export { GotoDefinitionAtPositionEditorContribution };

package/dist/workers/goToSymbol.js

@@ -0,0 +1,128 @@
+import { coalesce } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { matchesSomeScheme, Schemas } from '../../../../base/common/network.js';
+import { registerModelAndPositionCommand } from '../../../browser/editorExtensions.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { ReferencesModel } from './referencesModel.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function shouldIncludeLocationLink(sourceModel, loc) {
+    // Always allow the location if the request comes from a document with the same scheme.
+    if (loc.uri.scheme === sourceModel.uri.scheme) {
+        return true;
+    }
+    // Otherwise filter out locations from internal schemes
+    if (matchesSomeScheme(loc.uri, Schemas.walkThroughSnippet, Schemas.vscodeChatCodeBlock, Schemas.vscodeChatCodeCompareBlock)) {
+        return false;
+    }
+    return true;
+}
+async function getLocationLinks(model, position, registry, recursive, provide) {
+    const provider = registry.ordered(model, recursive);
+    // get results
+    const promises = provider.map((provider) => {
+        return Promise.resolve(provide(provider, model, position)).then(undefined, err => {
+            onUnexpectedExternalError(err);
+            return undefined;
+        });
+    });
+    const values = await Promise.all(promises);
+    return coalesce(values.flat()).filter(loc => shouldIncludeLocationLink(model, loc));
+}
+function getDefinitionsAtPosition(registry, model, position, recursive, token) {
+    return getLocationLinks(model, position, registry, recursive, (provider, model, position) => {
+        return provider.provideDefinition(model, position, token);
+    });
+}
+function getDeclarationsAtPosition(registry, model, position, recursive, token) {
+    return getLocationLinks(model, position, registry, recursive, (provider, model, position) => {
+        return provider.provideDeclaration(model, position, token);
+    });
+}
+function getImplementationsAtPosition(registry, model, position, recursive, token) {
+    return getLocationLinks(model, position, registry, recursive, (provider, model, position) => {
+        return provider.provideImplementation(model, position, token);
+    });
+}
+function getTypeDefinitionsAtPosition(registry, model, position, recursive, token) {
+    return getLocationLinks(model, position, registry, recursive, (provider, model, position) => {
+        return provider.provideTypeDefinition(model, position, token);
+    });
+}
+function getReferencesAtPosition(registry, model, position, compact, recursive, token) {
+    return getLocationLinks(model, position, registry, recursive, async (provider, model, position) => {
+        const result = (await provider.provideReferences(model, position, { includeDeclaration: true }, token))?.filter(ref => shouldIncludeLocationLink(model, ref));
+        if (!compact || !result || result.length !== 2) {
+            return result;
+        }
+        const resultWithoutDeclaration = (await provider.provideReferences(model, position, { includeDeclaration: false }, token))?.filter(ref => shouldIncludeLocationLink(model, ref));
+        if (resultWithoutDeclaration && resultWithoutDeclaration.length === 1) {
+            return resultWithoutDeclaration;
+        }
+        return result;
+    });
+}
+// -- API commands ----
+async function _sortedAndDeduped(callback) {
+    const rawLinks = await callback();
+    const model = new ReferencesModel(rawLinks, '');
+    const modelLinks = model.references.map(ref => ref.link);
+    model.dispose();
+    return modelLinks;
+}
+registerModelAndPositionCommand('_executeDefinitionProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getDefinitionsAtPosition(languageFeaturesService.definitionProvider, model, position, false, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeDefinitionProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getDefinitionsAtPosition(languageFeaturesService.definitionProvider, model, position, true, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeTypeDefinitionProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getTypeDefinitionsAtPosition(languageFeaturesService.typeDefinitionProvider, model, position, false, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeTypeDefinitionProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getTypeDefinitionsAtPosition(languageFeaturesService.typeDefinitionProvider, model, position, true, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeDeclarationProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getDeclarationsAtPosition(languageFeaturesService.declarationProvider, model, position, false, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeDeclarationProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getDeclarationsAtPosition(languageFeaturesService.declarationProvider, model, position, true, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeReferenceProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, false, false, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeReferenceProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, false, true, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeImplementationProvider', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getImplementationsAtPosition(languageFeaturesService.implementationProvider, model, position, false, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+registerModelAndPositionCommand('_executeImplementationProvider_recursive', (accessor, model, position) => {
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const promise = getImplementationsAtPosition(languageFeaturesService.implementationProvider, model, position, true, CancellationToken.None);
+    return _sortedAndDeduped(() => promise);
+});
+
+export { getDeclarationsAtPosition, getDefinitionsAtPosition, getImplementationsAtPosition, getReferencesAtPosition, getTypeDefinitionsAtPosition };

package/dist/workers/gotoError.js

@@ -0,0 +1,272 @@
+import { Codicon } from '../../../../base/common/codicons.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { registerEditorContribution, registerEditorAction, EditorCommand, registerEditorCommand, EditorAction } from '../../../browser/editorExtensions.js';
+import { ICodeEditorService } from '../../../browser/services/codeEditorService.js';
+import { Position } from '../../../common/core/position.js';
+import { Range } from '../../../common/core/range.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { IMarkerNavigationService } from './markerNavigationService.js';
+import { localize2, localize } from '../../../../nls.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
+import { MarkerNavigationWidget } from './gotoErrorWidget.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MarkerController_1;
+let MarkerController = class MarkerController {
+    static { MarkerController_1 = this; }
+    static { this.ID = 'editor.contrib.markerController'; }
+    static get(editor) {
+        return editor.getContribution(MarkerController_1.ID);
+    }
+    constructor(editor, _markerNavigationService, _contextKeyService, _editorService, _instantiationService) {
+        this._markerNavigationService = _markerNavigationService;
+        this._contextKeyService = _contextKeyService;
+        this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
+        this._sessionDispoables = new DisposableStore();
+        this._editor = editor;
+        this._widgetVisible = CONTEXT_MARKERS_NAVIGATION_VISIBLE.bindTo(this._contextKeyService);
+    }
+    dispose() {
+        this._cleanUp();
+        this._sessionDispoables.dispose();
+    }
+    _cleanUp() {
+        this._widgetVisible.reset();
+        this._sessionDispoables.clear();
+        this._widget = undefined;
+        this._model = undefined;
+    }
+    _getOrCreateModel(uri) {
+        if (this._model && this._model.matches(uri)) {
+            return this._model;
+        }
+        let reusePosition = false;
+        if (this._model) {
+            reusePosition = true;
+            this._cleanUp();
+        }
+        this._model = this._markerNavigationService.getMarkerList(uri);
+        if (reusePosition) {
+            this._model.move(true, this._editor.getModel(), this._editor.getPosition());
+        }
+        this._widget = this._instantiationService.createInstance(MarkerNavigationWidget, this._editor);
+        this._widget.onDidClose(() => this.close(), this, this._sessionDispoables);
+        this._widgetVisible.set(true);
+        this._sessionDispoables.add(this._model);
+        this._sessionDispoables.add(this._widget);
+        // follow cursor
+        this._sessionDispoables.add(this._editor.onDidChangeCursorPosition(e => {
+            if (!this._model?.selected || !Range.containsPosition(this._model?.selected.marker, e.position)) {
+                this._model?.resetIndex();
+            }
+        }));
+        // update markers
+        this._sessionDispoables.add(this._model.onDidChange(() => {
+            if (!this._widget || !this._widget.position || !this._model) {
+                return;
+            }
+            const info = this._model.find(this._editor.getModel().uri, this._widget.position);
+            if (info) {
+                this._widget.updateMarker(info.marker);
+            }
+            else {
+                this._widget.showStale();
+            }
+        }));
+        // open related
+        this._sessionDispoables.add(this._widget.onDidSelectRelatedInformation(related => {
+            this._editorService.openCodeEditor({
+                resource: related.resource,
+                options: { pinned: true, revealIfOpened: true, selection: Range.lift(related).collapseToStart() }
+            }, this._editor);
+            this.close(false);
+        }));
+        this._sessionDispoables.add(this._editor.onDidChangeModel(() => this._cleanUp()));
+        return this._model;
+    }
+    close(focusEditor = true) {
+        this._cleanUp();
+        if (focusEditor) {
+            this._editor.focus();
+        }
+    }
+    showAtMarker(marker) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const textModel = this._editor.getModel();
+        const model = this._getOrCreateModel(textModel.uri);
+        model.resetIndex();
+        model.move(true, textModel, new Position(marker.startLineNumber, marker.startColumn));
+        if (model.selected) {
+            this._widget.showAtMarker(model.selected.marker, model.selected.index, model.selected.total);
+        }
+    }
+    async navigate(next, multiFile) {
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        const textModel = this._editor.getModel();
+        const model = this._getOrCreateModel(multiFile ? undefined : textModel.uri);
+        model.move(next, textModel, this._editor.getPosition());
+        if (!model.selected) {
+            return;
+        }
+        if (model.selected.marker.resource.toString() !== textModel.uri.toString()) {
+            // show in different editor
+            this._cleanUp();
+            const otherEditor = await this._editorService.openCodeEditor({
+                resource: model.selected.marker.resource,
+                options: { pinned: false, revealIfOpened: true, selectionRevealType: 2 /* TextEditorSelectionRevealType.NearTop */, selection: model.selected.marker }
+            }, this._editor);
+            if (otherEditor) {
+                MarkerController_1.get(otherEditor)?.close();
+                MarkerController_1.get(otherEditor)?.navigate(next, multiFile);
+            }
+        }
+        else {
+            // show in this editor
+            this._widget.showAtMarker(model.selected.marker, model.selected.index, model.selected.total);
+        }
+    }
+};
+MarkerController = MarkerController_1 = __decorate([
+    __param(1, IMarkerNavigationService),
+    __param(2, IContextKeyService),
+    __param(3, ICodeEditorService),
+    __param(4, IInstantiationService)
+], MarkerController);
+class MarkerNavigationAction extends EditorAction {
+    constructor(_next, _multiFile, opts) {
+        super(opts);
+        this._next = _next;
+        this._multiFile = _multiFile;
+    }
+    async run(_accessor, editor) {
+        if (editor.hasModel()) {
+            await MarkerController.get(editor)?.navigate(this._next, this._multiFile);
+        }
+    }
+}
+class NextMarkerAction extends MarkerNavigationAction {
+    static { this.ID = 'editor.action.marker.next'; }
+    static { this.LABEL = localize2(1020, "Go to Next Problem (Error, Warning, Info)"); }
+    constructor() {
+        super(true, false, {
+            id: NextMarkerAction.ID,
+            label: NextMarkerAction.LABEL,
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 512 /* KeyMod.Alt */ | 66 /* KeyCode.F8 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            menuOpts: {
+                menuId: MarkerNavigationWidget.TitleMenu,
+                title: NextMarkerAction.LABEL.value,
+                icon: registerIcon('marker-navigation-next', Codicon.arrowDown, localize(1016, 'Icon for goto next marker.')),
+                group: 'navigation',
+                order: 1
+            }
+        });
+    }
+}
+class PrevMarkerAction extends MarkerNavigationAction {
+    static { this.ID = 'editor.action.marker.prev'; }
+    static { this.LABEL = localize2(1021, "Go to Previous Problem (Error, Warning, Info)"); }
+    constructor() {
+        super(false, false, {
+            id: PrevMarkerAction.ID,
+            label: PrevMarkerAction.LABEL,
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 66 /* KeyCode.F8 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            menuOpts: {
+                menuId: MarkerNavigationWidget.TitleMenu,
+                title: PrevMarkerAction.LABEL.value,
+                icon: registerIcon('marker-navigation-previous', Codicon.arrowUp, localize(1017, 'Icon for goto previous marker.')),
+                group: 'navigation',
+                order: 2
+            }
+        });
+    }
+}
+class NextMarkerInFilesAction extends MarkerNavigationAction {
+    constructor() {
+        super(true, true, {
+            id: 'editor.action.marker.nextInFiles',
+            label: localize2(1022, "Go to Next Problem in Files (Error, Warning, Info)"),
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 66 /* KeyCode.F8 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            menuOpts: {
+                menuId: MenuId.MenubarGoMenu,
+                title: localize(1018, "Next &&Problem"),
+                group: '6_problem_nav',
+                order: 1
+            }
+        });
+    }
+}
+class PrevMarkerInFilesAction extends MarkerNavigationAction {
+    constructor() {
+        super(false, true, {
+            id: 'editor.action.marker.prevInFiles',
+            label: localize2(1023, "Go to Previous Problem in Files (Error, Warning, Info)"),
+            precondition: undefined,
+            kbOpts: {
+                kbExpr: EditorContextKeys.focus,
+                primary: 1024 /* KeyMod.Shift */ | 66 /* KeyCode.F8 */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            menuOpts: {
+                menuId: MenuId.MenubarGoMenu,
+                title: localize(1019, "Previous &&Problem"),
+                group: '6_problem_nav',
+                order: 2
+            }
+        });
+    }
+}
+registerEditorContribution(MarkerController.ID, MarkerController, 4 /* EditorContributionInstantiation.Lazy */);
+registerEditorAction(NextMarkerAction);
+registerEditorAction(PrevMarkerAction);
+registerEditorAction(NextMarkerInFilesAction);
+registerEditorAction(PrevMarkerInFilesAction);
+const CONTEXT_MARKERS_NAVIGATION_VISIBLE = new RawContextKey('markersNavigationVisible', false);
+const MarkerCommand = EditorCommand.bindToContribution(MarkerController.get);
+registerEditorCommand(new MarkerCommand({
+    id: 'closeMarkersNavigation',
+    precondition: CONTEXT_MARKERS_NAVIGATION_VISIBLE,
+    handler: x => x.close(),
+    kbOpts: {
+        weight: 100 /* KeybindingWeight.EditorContrib */ + 50,
+        kbExpr: EditorContextKeys.focus,
+        primary: 9 /* KeyCode.Escape */,
+        secondary: [1024 /* KeyMod.Shift */ | 9 /* KeyCode.Escape */]
+    }
+}));
+
+export { MarkerController, NextMarkerAction };