@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatFollowups.d.ts

@@ -0,0 +1,13 @@
+import { IButtonStyles } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { IChatFollowup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+export declare class ChatFollowups<T extends IChatFollowup> extends Disposable {
+    private readonly location;
+    private readonly options;
+    private readonly clickHandler;
+    private readonly chatAgentService;
+    constructor(container: HTMLElement, followups: T[], location: ChatAgentLocation, options: IButtonStyles | undefined, clickHandler: (followup: T) => void, chatAgentService: IChatAgentService);
+    private renderFollowup;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatFollowups.js

@@ -0,0 +1,52 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { formatChatQuestion } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+
+const $ = $$1;
+let ChatFollowups = class ChatFollowups extends Disposable {
+    constructor(container, followups, location, options, clickHandler, chatAgentService) {
+        super();
+        this.location = location;
+        this.options = options;
+        this.clickHandler = clickHandler;
+        this.chatAgentService = chatAgentService;
+        const followupsContainer = append(container, $('.interactive-session-followups'));
+        followups.forEach(followup => this.renderFollowup(followupsContainer, followup));
+    }
+    renderFollowup(container, followup) {
+        if (!this.chatAgentService.getDefaultAgent(this.location)) {
+            return;
+        }
+        const tooltipPrefix = formatChatQuestion(this.chatAgentService, this.location, '', followup.agentId, followup.subCommand);
+        if (tooltipPrefix === undefined) {
+            return;
+        }
+        const baseTitle = followup.kind === 'reply' ?
+            (followup.title || followup.message)
+            : followup.title;
+        const message = followup.kind === 'reply' ? followup.message : followup.title;
+        const tooltip = (tooltipPrefix +
+            (followup.tooltip || message)).trim();
+        const button = this._register(( new Button(container, { ...this.options, title: tooltip })));
+        if (followup.kind === 'reply') {
+            button.element.classList.add('interactive-followup-reply');
+        }
+        else if (followup.kind === 'command') {
+            button.element.classList.add('interactive-followup-command');
+        }
+        button.element.ariaLabel = ( localize(5293, "Follow up question: {0}", baseTitle));
+        button.label = ( new MarkdownString(baseTitle));
+        this._register(button.onDidClick(() => this.clickHandler(followup)));
+    }
+};
+ChatFollowups = ( __decorate([
+    ( __param(5, IChatAgentService))
+], ChatFollowups));
+
+export { ChatFollowups };

package/vscode/src/vs/workbench/contrib/chat/browser/chatInlineAnchorWidget.d.ts

@@ -0,0 +1,39 @@
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { INotebookDocumentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service";
+import { IWorkspaceSymbol } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/search/common/search";
+import { IChatContentInlineReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service";
+type ContentRefData = {
+    readonly kind: "symbol";
+    readonly symbol: IWorkspaceSymbol;
+} | {
+    readonly kind?: undefined;
+    readonly uri: URI;
+    readonly range?: IRange;
+};
+export declare function renderFileWidgets(element: HTMLElement, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, disposables: DisposableStore): void;
+export declare class InlineAnchorWidget extends Disposable {
+    private readonly element;
+    readonly inlineReference: IChatContentInlineReference;
+    private readonly notebookDocumentService;
+    static readonly className = "chat-inline-anchor-widget";
+    private readonly _chatResourceContext;
+    readonly data: ContentRefData;
+    constructor(element: HTMLAnchorElement | HTMLElement, inlineReference: IChatContentInlineReference, originalContextKeyService: IContextKeyService, contextMenuService: IContextMenuService, fileService: IFileService, hoverService: IHoverService, instantiationService: IInstantiationService, labelService: ILabelService, languageService: ILanguageService, menuService: IMenuService, modelService: IModelService, telemetryService: ITelemetryService, themeService: IThemeService, notebookDocumentService: INotebookDocumentService);
+    getHTMLElement(): HTMLElement;
+    private getCellIndex;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/chatInlineAnchorWidget.js

@@ -0,0 +1,409 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, addDisposableListener, EventType, getWindow, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { SymbolKinds } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { getIconClasses } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { DefinitionAction } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/gotoSymbol/browser/goToCommands';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getFlatContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId, registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { FolderThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { fillEditorsDragData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/dnd';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { INotebookDocumentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
+import { ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { chatAttachmentResourceContextKey, hookUpSymbolAttachmentDragAndContextMenu } from './chatAttachmentWidgets.js';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service';
+
+var InlineAnchorWidget_1;
+function renderFileWidgets(element, instantiationService, chatMarkdownAnchorService, disposables) {
+    const links = element.querySelectorAll('a');
+    links.forEach(a => {
+        if (!a.textContent?.trim()) {
+            const href = a.getAttribute('data-href');
+            const uri = href ? ( URI.parse(href)) : undefined;
+            if (uri?.scheme) {
+                const widget = instantiationService.createInstance(InlineAnchorWidget, a, { kind: 'inlineReference', inlineReference: uri });
+                disposables.add(chatMarkdownAnchorService.register(widget));
+                disposables.add(widget);
+            }
+        }
+    });
+}
+let InlineAnchorWidget = class InlineAnchorWidget extends Disposable {
+    static { InlineAnchorWidget_1 = this; }
+    static { this.className = 'chat-inline-anchor-widget'; }
+    constructor(element, inlineReference, originalContextKeyService, contextMenuService, fileService, hoverService, instantiationService, labelService, languageService, menuService, modelService, telemetryService, themeService, notebookDocumentService) {
+        super();
+        this.element = element;
+        this.inlineReference = inlineReference;
+        this.notebookDocumentService = notebookDocumentService;
+        this.data = 'uri' in inlineReference.inlineReference
+            ? inlineReference.inlineReference
+            : 'name' in inlineReference.inlineReference
+                ? { kind: 'symbol', symbol: inlineReference.inlineReference }
+                : { uri: inlineReference.inlineReference };
+        const contextKeyService = this._register(originalContextKeyService.createScoped(element));
+        this._chatResourceContext = chatAttachmentResourceContextKey.bindTo(contextKeyService);
+        element.classList.add(InlineAnchorWidget_1.className, 'show-file-icons');
+        let iconText;
+        let iconClasses;
+        let location;
+        let updateContextKeys;
+        if (this.data.kind === 'symbol') {
+            const symbol = this.data.symbol;
+            location = this.data.symbol.location;
+            iconText = [this.data.symbol.name];
+            iconClasses = ['codicon', ...getIconClasses(modelService, languageService, undefined, undefined, SymbolKinds.toIcon(symbol.kind))];
+            this._store.add(instantiationService.invokeFunction(accessor => hookUpSymbolAttachmentDragAndContextMenu(accessor, element, contextKeyService, { value: symbol.location, name: symbol.name, kind: symbol.kind }, MenuId.ChatInlineSymbolAnchorContext)));
+        }
+        else {
+            location = this.data;
+            const filePathLabel = labelService.getUriBasenameLabel(location.uri);
+            if (location.range && this.data.kind !== 'symbol') {
+                const suffix = location.range.startLineNumber === location.range.endLineNumber
+                    ? `:${location.range.startLineNumber}`
+                    : `:${location.range.startLineNumber}-${location.range.endLineNumber}`;
+                iconText = [filePathLabel, $('span.label-suffix', undefined, suffix)];
+            }
+            else if (location.uri.scheme === 'vscode-notebook-cell' && this.data.kind !== 'symbol') {
+                iconText = [`${filePathLabel} • cell${this.getCellIndex(location.uri)}`];
+            }
+            else {
+                iconText = [filePathLabel];
+            }
+            let fileKind = location.uri.path.endsWith('/') ? FileKind.FOLDER : FileKind.FILE;
+            const recomputeIconClasses = () => getIconClasses(modelService, languageService, location.uri, fileKind, fileKind === FileKind.FOLDER && !themeService.getFileIconTheme().hasFolderIcons ? FolderThemeIcon : undefined);
+            iconClasses = recomputeIconClasses();
+            const refreshIconClasses = () => {
+                iconEl.classList.remove(...iconClasses);
+                iconClasses = recomputeIconClasses();
+                iconEl.classList.add(...iconClasses);
+            };
+            this._register(themeService.onDidFileIconThemeChange(() => {
+                refreshIconClasses();
+            }));
+            const isFolderContext = ExplorerFolderContext.bindTo(contextKeyService);
+            fileService.stat(location.uri)
+                .then(stat => {
+                isFolderContext.set(stat.isDirectory);
+                if (stat.isDirectory) {
+                    fileKind = FileKind.FOLDER;
+                    refreshIconClasses();
+                }
+            })
+                .catch(() => { });
+            this._register(addDisposableListener(element, EventType.CONTEXT_MENU, async (domEvent) => {
+                const event = ( new StandardMouseEvent(getWindow(domEvent), domEvent));
+                EventHelper.stop(domEvent, true);
+                try {
+                    await updateContextKeys?.();
+                }
+                catch (e) {
+                    console.error(e);
+                }
+                if (this._store.isDisposed) {
+                    return;
+                }
+                contextMenuService.showContextMenu({
+                    contextKeyService,
+                    getAnchor: () => event,
+                    getActions: () => {
+                        const menu = menuService.getMenuActions(MenuId.ChatInlineResourceAnchorContext, contextKeyService, { arg: location.uri });
+                        return getFlatContextMenuActions(menu);
+                    },
+                });
+            }));
+            if (location.range) {
+                if (location.range.startLineNumber === location.range.endLineNumber) {
+                    element.setAttribute('aria-label', ( localize(5294, "{0} line {1}", filePathLabel, location.range.startLineNumber)));
+                }
+                else {
+                    element.setAttribute('aria-label', ( localize(
+                        5295,
+                        "{0} lines {1} to {2}",
+                        filePathLabel,
+                        location.range.startLineNumber,
+                        location.range.endLineNumber
+                    )));
+                }
+            }
+        }
+        const resourceContextKey = this._register(( new ResourceContextKey(contextKeyService, fileService, languageService, modelService)));
+        resourceContextKey.set(location.uri);
+        this._chatResourceContext.set(( location.uri.toString()));
+        const iconEl = $('span.icon');
+        iconEl.classList.add(...iconClasses);
+        element.replaceChildren(iconEl, $('span.icon-label', {}, ...iconText));
+        const fragment = location.range ? `${location.range.startLineNumber},${location.range.startColumn}` : '';
+        element.setAttribute('data-href', ( (fragment ? location.uri.with({ fragment }) : location.uri).toString()));
+        const relativeLabel = labelService.getUriLabel(location.uri, { relative: true });
+        this._register(hoverService.setupManagedHover(getDefaultHoverDelegate('element'), element, relativeLabel));
+        if (this.data.kind !== 'symbol') {
+            element.draggable = true;
+            this._register(addDisposableListener(element, 'dragstart', e => {
+                const stat = {
+                    resource: location.uri,
+                    selection: location.range,
+                };
+                instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, [stat], e));
+                e.dataTransfer?.setDragImage(element, 0, 0);
+            }));
+        }
+    }
+    getHTMLElement() {
+        return this.element;
+    }
+    getCellIndex(location) {
+        const notebook = this.notebookDocumentService.getNotebook(location);
+        const index = notebook?.getCellIndex(location) ?? -1;
+        return index >= 0 ? ` ${index + 1}` : '';
+    }
+};
+InlineAnchorWidget = InlineAnchorWidget_1 = ( __decorate([
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IHoverService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, IMenuService)),
+    ( __param(10, IModelService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IThemeService)),
+    ( __param(13, INotebookDocumentService))
+], InlineAnchorWidget));
+registerAction2(class AddFileToChatAction extends Action2 {
+    static { this.id = 'chat.inlineResourceAnchor.addFileToChat'; }
+    constructor() {
+        super({
+            id: AddFileToChatAction.id,
+            title: ( localize2(5296, "Add File to Chat")),
+            menu: [{
+                    id: MenuId.ChatInlineResourceAnchorContext,
+                    group: 'chat',
+                    order: 1,
+                    when: ( ExplorerFolderContext.negate()),
+                }]
+        });
+    }
+    async run(accessor, resource) {
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = chatWidgetService.lastFocusedWidget;
+        if (widget) {
+            widget.attachmentModel.addFile(resource);
+        }
+    }
+});
+registerAction2(class CopyResourceAction extends Action2 {
+    static { this.id = 'chat.inlineResourceAnchor.copyResource'; }
+    constructor() {
+        super({
+            id: CopyResourceAction.id,
+            title: ( localize2(5297, "Copy")),
+            f1: false,
+            precondition: chatAttachmentResourceContextKey,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyC,
+            }
+        });
+    }
+    async run(accessor) {
+        const chatWidgetService = accessor.get(IChatMarkdownAnchorService);
+        const clipboardService = accessor.get(IClipboardService);
+        const anchor = chatWidgetService.lastFocusedAnchor;
+        if (!anchor) {
+            return;
+        }
+        const resource = anchor.data.kind === 'symbol' ? anchor.data.symbol.location.uri : anchor.data.uri;
+        clipboardService.writeResources([resource]);
+    }
+});
+registerAction2(class OpenToSideResourceAction extends Action2 {
+    static { this.id = 'chat.inlineResourceAnchor.openToSide'; }
+    constructor() {
+        super({
+            id: OpenToSideResourceAction.id,
+            title: ( localize2(5298, "Open to the Side")),
+            f1: false,
+            precondition: chatAttachmentResourceContextKey,
+            keybinding: {
+                weight: KeybindingWeight.ExternalExtension + 2,
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyCode.Enter
+                },
+            },
+            menu: ( [MenuId.ChatInlineSymbolAnchorContext, MenuId.ChatInputSymbolAttachmentContext].map(id => ({
+                id: id,
+                group: 'navigation',
+                order: 1
+            })))
+        });
+    }
+    async run(accessor, arg) {
+        const editorService = accessor.get(IEditorService);
+        const target = this.getTarget(accessor, arg);
+        if (!target) {
+            return;
+        }
+        const input = URI.isUri(target)
+            ? { resource: target }
+            : {
+                resource: target.uri, options: {
+                    selection: {
+                        startColumn: target.range.startColumn,
+                        startLineNumber: target.range.startLineNumber,
+                    }
+                }
+            };
+        await editorService.openEditors([input], SIDE_GROUP);
+    }
+    getTarget(accessor, arg) {
+        const chatWidgetService = accessor.get(IChatMarkdownAnchorService);
+        if (arg) {
+            return arg;
+        }
+        const anchor = chatWidgetService.lastFocusedAnchor;
+        if (!anchor) {
+            return undefined;
+        }
+        return anchor.data.kind === 'symbol' ? anchor.data.symbol.location : anchor.data.uri;
+    }
+});
+registerAction2(class GoToDefinitionAction extends Action2 {
+    static { this.id = 'chat.inlineSymbolAnchor.goToDefinition'; }
+    constructor() {
+        super({
+            id: GoToDefinitionAction.id,
+            title: {
+                ...( localize2(5299, "Go to Definition")),
+                mnemonicTitle: ( localize(5300, "Go to &&Definition")),
+            },
+            menu: ( [MenuId.ChatInlineSymbolAnchorContext, MenuId.ChatInputSymbolAttachmentContext].map(id => ({
+                id,
+                group: '4_symbol_nav',
+                order: 1.1,
+                when: EditorContextKeys.hasDefinitionProvider,
+            })))
+        });
+    }
+    async run(accessor, location) {
+        const editorService = accessor.get(ICodeEditorService);
+        const instantiationService = accessor.get(IInstantiationService);
+        await openEditorWithSelection(editorService, location);
+        const action = ( new DefinitionAction(
+            { openToSide: false, openInPeek: false, muteMessage: true },
+            { title: { value: '', original: '' }, id: '', precondition: undefined }
+        ));
+        return instantiationService.invokeFunction(accessor => action.run(accessor));
+    }
+});
+async function openEditorWithSelection(editorService, location) {
+    await editorService.openCodeEditor({
+        resource: location.uri, options: {
+            selection: {
+                startColumn: location.range.startColumn,
+                startLineNumber: location.range.startLineNumber,
+            }
+        }
+    }, null);
+}
+async function runGoToCommand(accessor, command, location) {
+    const editorService = accessor.get(ICodeEditorService);
+    const commandService = accessor.get(ICommandService);
+    await openEditorWithSelection(editorService, location);
+    return commandService.executeCommand(command);
+}
+registerAction2(class GoToTypeDefinitionsAction extends Action2 {
+    static { this.id = 'chat.inlineSymbolAnchor.goToTypeDefinitions'; }
+    constructor() {
+        super({
+            id: GoToTypeDefinitionsAction.id,
+            title: {
+                ...( localize2(5301, "Go to Type Definitions")),
+                mnemonicTitle: ( localize(5302, "Go to &&Type Definitions")),
+            },
+            menu: ( [MenuId.ChatInlineSymbolAnchorContext, MenuId.ChatInputSymbolAttachmentContext].map(id => ({
+                id,
+                group: '4_symbol_nav',
+                order: 1.1,
+                when: EditorContextKeys.hasTypeDefinitionProvider,
+            }))),
+        });
+    }
+    async run(accessor, location) {
+        await runGoToCommand(accessor, 'editor.action.goToTypeDefinition', location);
+    }
+});
+registerAction2(class GoToImplementations extends Action2 {
+    static { this.id = 'chat.inlineSymbolAnchor.goToImplementations'; }
+    constructor() {
+        super({
+            id: GoToImplementations.id,
+            title: {
+                ...( localize2(5303, "Go to Implementations")),
+                mnemonicTitle: ( localize(5304, "Go to &&Implementations")),
+            },
+            menu: ( [MenuId.ChatInlineSymbolAnchorContext, MenuId.ChatInputSymbolAttachmentContext].map(id => ({
+                id,
+                group: '4_symbol_nav',
+                order: 1.2,
+                when: EditorContextKeys.hasImplementationProvider,
+            }))),
+        });
+    }
+    async run(accessor, location) {
+        await runGoToCommand(accessor, 'editor.action.goToImplementation', location);
+    }
+});
+registerAction2(class GoToReferencesAction extends Action2 {
+    static { this.id = 'chat.inlineSymbolAnchor.goToReferences'; }
+    constructor() {
+        super({
+            id: GoToReferencesAction.id,
+            title: {
+                ...( localize2(5305, "Go to References")),
+                mnemonicTitle: ( localize(5306, "Go to &&References")),
+            },
+            menu: ( [MenuId.ChatInlineSymbolAnchorContext, MenuId.ChatInputSymbolAttachmentContext].map(id => ({
+                id,
+                group: '4_symbol_nav',
+                order: 1.3,
+                when: EditorContextKeys.hasReferenceProvider,
+            }))),
+        });
+    }
+    async run(accessor, location) {
+        await runGoToCommand(accessor, 'editor.action.goToReferences', location);
+    }
+});
+
+export { InlineAnchorWidget, renderFileWidgets };