@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/editor/chatInputCompletions.js

@@ -1,1081 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
-import { isPatternInWord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
-import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
-import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import { isCodeEditor, getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
-import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { getWordAtText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper';
-import { CompletionItemKind, SymbolKinds } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
-import { IOutlineModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/documentSymbols/browser/outlineModel.service';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.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 { 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 { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
-import { EditorsOrder, isDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
-import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
-import { McpPromptArgumentPick } from '../../../../../mcp/browser/mcpPromptArgumentPick.js';
-import { McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
-import { searchFilesAndFolders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/search/browser/searchChatContext';
-import { getFullyQualifiedId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents';
-import { IChatAgentService, IChatAgentNameService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
-import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
-import { getAttachableImageExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
-import { ChatRequestAgentPart, chatSubcommandLeader, chatAgentLeader, ChatRequestAgentSubcommandPart, ChatRequestSlashPromptPart, ChatRequestTextPart, chatVariableLeader, ChatRequestToolPart, ChatRequestToolSetPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
-import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
-import { ChatAgentLocation, ChatModeKind, isSupportedChatFileScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
-import { ChatSubmitAction } from '../../../actions/chatExecuteActions.js';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
-import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables';
-
-var BuiltinDynamicCompletions_1, ToolCompletions_1;
-let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, chatSlashCommandService, promptsService, mcpService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatSlashCommandService = chatSlashCommandService;
-        this.promptsService = promptsService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'globalSlashCommands',
-            triggerCharacters: [chatSubcommandLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const parsedRequest = widget.parsedInput.parts;
-                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
-                if (usedAgent) {
-                    return;
-                }
-                const slashCommands = this.chatSlashCommandService.getCommands(widget.location, widget.input.currentModeKind);
-                if (!slashCommands) {
-                    return null;
-                }
-                return {
-                    suggestions: ( slashCommands.map((c, i) => {
-                        const withSlash = `/${c.command}`;
-                        return {
-                            label: withSlash,
-                            insertText: c.executeImmediately ? '' : `${withSlash} `,
-                            documentation: c.detail,
-                            range,
-                            sortText: c.sortText ?? 'a'.repeat(i + 1),
-                            kind: CompletionItemKind.Text,
-                            command: c.executeImmediately ? { id: ChatSubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
-                        };
-                    }))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'globalSlashCommandsAt',
-            triggerCharacters: [chatAgentLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /@\w*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const slashCommands = this.chatSlashCommandService.getCommands(widget.location, widget.input.currentModeKind);
-                if (!slashCommands) {
-                    return null;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                return {
-                    suggestions: ( slashCommands.map((c, i) => {
-                        const withSlash = `${chatSubcommandLeader}${c.command}`;
-                        return {
-                            label: withSlash,
-                            insertText: c.executeImmediately ? '' : `${withSlash} `,
-                            documentation: c.detail,
-                            range,
-                            filterText: `${chatAgentLeader}${c.command}`,
-                            sortText: c.sortText ?? 'z'.repeat(i + 1),
-                            kind: CompletionItemKind.Text,
-                            command: c.executeImmediately ? { id: ChatSubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
-                        };
-                    }))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'promptSlashCommands',
-            triggerCharacters: [chatSubcommandLeader],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const parsedRequest = widget.parsedInput.parts;
-                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
-                if (usedAgent) {
-                    return;
-                }
-                const promptCommands = await this.promptsService.getPromptSlashCommands(token);
-                if (promptCommands.length === 0) {
-                    return null;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                return {
-                    suggestions: ( promptCommands.map((c, i) => {
-                        const label = `/${c.name}`;
-                        const description = c.description;
-                        return {
-                            label: { label, description },
-                            insertText: `${label} `,
-                            documentation: c.description,
-                            range,
-                            sortText: 'a'.repeat(i + 1),
-                            kind: CompletionItemKind.Text,
-                        };
-                    }))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'mcpPromptSlashCommands',
-            triggerCharacters: [chatSubcommandLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /\/[a-z0-9_.-]*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                return {
-                    suggestions: mcpService.servers.get().flatMap(server => ( server.prompts.get().map((prompt) => {
-                        const label = `/mcp.${prompt.id}`;
-                        return {
-                            label: { label, description: prompt.description },
-                            command: {
-                                id: StartParameterizedPromptAction.ID,
-                                title: prompt.name,
-                                arguments: [model, server, prompt, `${label} `],
-                            },
-                            insertText: `${label} `,
-                            range,
-                            kind: CompletionItemKind.Text,
-                        };
-                    })))
-                };
-            }
-        }));
-    }
-};
-SlashCommandCompletions = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatSlashCommandService)),
-    ( __param(3, IPromptsService)),
-    ( __param(4, IMcpService))
-], SlashCommandCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, LifecyclePhase.Eventually);
-let AgentCompletions = class AgentCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, chatAgentService, chatAgentNameService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatAgentService = chatAgentService;
-        this.chatAgentNameService = chatAgentNameService;
-        const subCommandProvider = {
-            _debugDisplayName: 'chatAgentSubcommand',
-            triggerCharacters: [chatSubcommandLeader],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, /\/\w*/g);
-                if (!range) {
-                    return;
-                }
-                const usedAgent = this.getCurrentAgentForWidget(widget);
-                if (!usedAgent || usedAgent.command) {
-                    return;
-                }
-                return {
-                    suggestions: ( usedAgent.agent.slashCommands.map((c, i) => {
-                        const withSlash = `/${c.name}`;
-                        return {
-                            label: withSlash,
-                            insertText: `${withSlash} `,
-                            documentation: c.description,
-                            range,
-                            kind: CompletionItemKind.Text,
-                        };
-                    }))
-                };
-            }
-        };
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, subCommandProvider));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentAndSubcommand',
-            triggerCharacters: [chatAgentLeader],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                const viewModel = widget?.viewModel;
-                if (!widget || !viewModel) {
-                    return;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const agents = this.chatAgentService.getAgents()
-                    .filter(a => a.locations.includes(widget.location));
-                const getFilterText = (agent, command) => {
-                    const dummyPrefix = agent.id === 'github.copilot.terminalPanel' ? `0000` : ``;
-                    return `${chatAgentLeader}${dummyPrefix}${agent.name}.${command}`;
-                };
-                const justAgents = ( agents
-                    .filter(a => !a.isDefault)
-                    .map(agent => {
-                    const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
-                    const detail = agent.description;
-                    return {
-                        label: isDupe ?
-                            { label: agentLabel, description: agent.description, detail: ` (${agent.publisherDisplayName})` } :
-                            agentLabel,
-                        documentation: detail,
-                        filterText: `${chatAgentLeader}${agent.name}`,
-                        insertText: `${agentLabel} `,
-                        range,
-                        kind: CompletionItemKind.Text,
-                        sortText: `${chatAgentLeader}${agent.name}`,
-                        command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
-                    };
-                }));
-                return {
-                    suggestions: justAgents.concat(coalesce(agents.flatMap(agent => ( agent.slashCommands.map((c, i) => {
-                        if (agent.isDefault && this.chatAgentService.getDefaultAgent(widget.location, widget.input.currentModeKind)?.id !== agent.id) {
-                            return;
-                        }
-                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
-                        const label = `${agentLabel} ${chatSubcommandLeader}${c.name}`;
-                        const item = {
-                            label: isDupe ?
-                                { label, description: c.description, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined } :
-                                label,
-                            documentation: c.description,
-                            filterText: getFilterText(agent, c.name),
-                            commitCharacters: [' '],
-                            insertText: label + ' ',
-                            range,
-                            kind: CompletionItemKind.Text,
-                            sortText: `x${chatAgentLeader}${agent.name}${c.name}`,
-                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
-                        };
-                        if (agent.isDefault) {
-                            const label = `${chatSubcommandLeader}${c.name}`;
-                            item.label = label;
-                            item.insertText = `${label} `;
-                            item.documentation = c.description;
-                        }
-                        return item;
-                    })))))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatAgentAndSubcommand',
-            triggerCharacters: [chatSubcommandLeader],
-            provideCompletionItems: async (model, position, _context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                const viewModel = widget?.viewModel;
-                if (!widget || !viewModel) {
-                    return;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
-                if (!range) {
-                    return null;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const agents = this.chatAgentService.getAgents()
-                    .filter(a => a.locations.includes(widget.location) && a.modes.includes(widget.input.currentModeKind));
-                return {
-                    suggestions: coalesce(agents.flatMap(agent => ( agent.slashCommands.map((c, i) => {
-                        if (agent.isDefault && this.chatAgentService.getDefaultAgent(widget.location, widget.input.currentModeKind)?.id !== agent.id) {
-                            return;
-                        }
-                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
-                        const withSlash = `${chatSubcommandLeader}${c.name}`;
-                        const extraSortText = agent.id === 'github.copilot.terminalPanel' ? `z` : ``;
-                        const sortText = `${chatSubcommandLeader}${extraSortText}${agent.name}${c.name}`;
-                        const item = {
-                            label: { label: withSlash, description: agentLabel, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined },
-                            commitCharacters: [' '],
-                            insertText: `${agentLabel} ${withSlash} `,
-                            documentation: `(${agentLabel}) ${c.description ?? ''}`,
-                            range,
-                            kind: CompletionItemKind.Text,
-                            sortText,
-                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
-                        };
-                        if (agent.isDefault) {
-                            const label = `${chatSubcommandLeader}${c.name}`;
-                            item.label = label;
-                            item.insertText = `${label} `;
-                            item.documentation = c.description;
-                        }
-                        return item;
-                    }))))
-                };
-            }
-        }));
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'installChatExtensions',
-            triggerCharacters: [chatAgentLeader],
-            provideCompletionItems: async (model, position, _context, token) => {
-                if (!model.getLineContent(1).startsWith(chatAgentLeader)) {
-                    return;
-                }
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (widget?.location !== ChatAgentLocation.Chat || widget.input.currentModeKind !== ChatModeKind.Ask) {
-                    return;
-                }
-                if (widget.lockedAgentId) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
-                if (!range) {
-                    return;
-                }
-                if (!isEmptyUpToCompletionWord(model, range)) {
-                    return;
-                }
-                const label = ( localize(5837, "Install Chat Extensions..."));
-                const item = {
-                    label,
-                    insertText: '',
-                    range,
-                    kind: CompletionItemKind.Text,
-                    command: { id: 'workbench.extensions.search', title: '', arguments: ['@tag:chat-participant'] },
-                    filterText: chatAgentLeader + label,
-                    sortText: 'zzz'
-                };
-                return {
-                    suggestions: [item]
-                };
-            }
-        }));
-    }
-    getCurrentAgentForWidget(widget) {
-        if (widget.lockedAgentId) {
-            const usedAgent = this.chatAgentService.getAgent(widget.lockedAgentId);
-            return usedAgent && { agent: usedAgent };
-        }
-        const parsedRequest = widget.parsedInput.parts;
-        const usedAgentIdx = parsedRequest.findIndex((p) => p instanceof ChatRequestAgentPart);
-        if (usedAgentIdx < 0) {
-            return;
-        }
-        const usedAgent = parsedRequest[usedAgentIdx];
-        const usedOtherCommand = parsedRequest.find(p => p instanceof ChatRequestAgentSubcommandPart || p instanceof ChatRequestSlashPromptPart);
-        if (usedOtherCommand) {
-            return {
-                agent: usedAgent.agent,
-                command: usedOtherCommand instanceof ChatRequestAgentSubcommandPart ? usedOtherCommand.command.name : undefined
-            };
-        }
-        for (const partAfterAgent of parsedRequest.slice(usedAgentIdx + 1)) {
-            if (!(partAfterAgent instanceof ChatRequestTextPart) || !partAfterAgent.text.trim().match(/^(\/\w*)?$/)) {
-                return;
-            }
-        }
-        return { agent: usedAgent.agent };
-    }
-    getAgentCompletionDetails(agent) {
-        const isAllowed = this.chatAgentNameService.getAgentNameRestriction(agent);
-        const agentLabel = `${chatAgentLeader}${isAllowed ? agent.name : getFullyQualifiedId(agent)}`;
-        const isDupe = isAllowed && this.chatAgentService.agentHasDupeName(agent.id);
-        return { label: agentLabel, isDupe };
-    }
-};
-AgentCompletions = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatAgentService)),
-    ( __param(3, IChatAgentNameService))
-], AgentCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, LifecyclePhase.Eventually);
-class AssignSelectedAgentAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.assignSelectedAgent'; }
-    constructor() {
-        super({
-            id: AssignSelectedAgentAction.ID,
-            title: ''
-        });
-    }
-    async run(accessor, ...args) {
-        const arg = args[0];
-        if (!arg || !arg.widget || !arg.agent) {
-            return;
-        }
-        if (!arg.agent.modes.includes(arg.widget.input.currentModeKind)) {
-            arg.widget.input.setChatMode(arg.agent.modes[0]);
-        }
-        arg.widget.lastSelectedAgent = arg.agent;
-    }
-}
-registerAction2(AssignSelectedAgentAction);
-class StartParameterizedPromptAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.startParameterizedPrompt'; }
-    constructor() {
-        super({
-            id: StartParameterizedPromptAction.ID,
-            title: ''
-        });
-    }
-    async run(accessor, model, server, prompt, textToReplace) {
-        if (!model || !prompt) {
-            return;
-        }
-        const instantiationService = accessor.get(IInstantiationService);
-        const notificationService = accessor.get(INotificationService);
-        const widgetService = accessor.get(IChatWidgetService);
-        const fileService = accessor.get(IFileService);
-        const chatWidget = await widgetService.revealWidget(true);
-        if (!chatWidget) {
-            return;
-        }
-        const lastPosition = model.getFullModelRange().collapseToEnd();
-        const getPromptIndex = () => model.findMatches(textToReplace, true, false, true, null, false)[0];
-        const replaceTextWith = (value) => model.applyEdits([{
-                range: getPromptIndex()?.range || lastPosition,
-                text: value,
-            }]);
-        const store = ( new DisposableStore());
-        const cts = store.add(( new CancellationTokenSource()));
-        store.add(chatWidget.input.startGenerating());
-        store.add(model.onDidChangeContent(() => {
-            if (getPromptIndex()) {
-                cts.cancel();
-            }
-        }));
-        model.changeDecorations(accessor => {
-            const id = accessor.addDecoration(lastPosition, {
-                description: 'mcp-prompt-spinner',
-                showIfCollapsed: true,
-                after: {
-                    content: ' ',
-                    inlineClassNameAffectsLetterSpacing: true,
-                    inlineClassName: ThemeIcon.asClassName(ThemeIcon.modify(Codicon.loading, 'spin')) + ' chat-prompt-spinner',
-                }
-            });
-            store.add(toDisposable(() => {
-                model.changeDecorations(a => a.removeDecoration(id));
-            }));
-        });
-        const pick = store.add(instantiationService.createInstance(McpPromptArgumentPick, prompt));
-        try {
-            await server.start();
-            const args = await pick.createArgs();
-            if (!args) {
-                replaceTextWith('');
-                return;
-            }
-            let messages;
-            try {
-                messages = await prompt.resolve(args, cts.token);
-            }
-            catch (e) {
-                if (!cts.token.isCancellationRequested) {
-                    notificationService.error(( localize(5838, "Error resolving prompt: {0}", String(e))));
-                }
-                replaceTextWith('');
-                return;
-            }
-            const toAttach = [];
-            const attachBlob = async (mimeType, contents, uriStr, isText = false) => {
-                let validURI;
-                if (uriStr) {
-                    for (const uri of [( URI.parse(uriStr)), McpResourceURI.fromServer(server.definition, uriStr)]) {
-                        try {
-                            validURI ||= (await fileService.exists(uri)) ? uri : undefined;
-                        }
-                        catch {
-                        }
-                    }
-                }
-                if (isText) {
-                    if (validURI) {
-                        toAttach.push({
-                            id: generateUuid(),
-                            kind: 'file',
-                            value: validURI,
-                            name: basename(validURI),
-                        });
-                    }
-                    else {
-                        toAttach.push({
-                            id: generateUuid(),
-                            kind: 'generic',
-                            value: contents,
-                            name: ( localize(5839, 'Prompt Resource')),
-                        });
-                    }
-                }
-                else if (mimeType && getAttachableImageExtension(mimeType)) {
-                    const resized = await resizeImage(contents)
-                        .catch(() => decodeBase64(contents).buffer);
-                    chatWidget.attachmentModel.addContext({
-                        id: generateUuid(),
-                        name: ( localize(5840, 'Prompt Image')),
-                        fullName: ( localize(5840, 'Prompt Image')),
-                        value: resized,
-                        kind: 'image',
-                        references: validURI && [{ reference: validURI, kind: 'reference' }],
-                    });
-                }
-                else if (validURI) {
-                    toAttach.push({
-                        id: generateUuid(),
-                        kind: 'file',
-                        value: validURI,
-                        name: basename(validURI),
-                    });
-                }
-                else {
-                }
-            };
-            const hasMultipleRoles = ( messages.some(m => m.role !== messages[0].role));
-            let input = '';
-            for (const message of messages) {
-                switch (message.content.type) {
-                    case 'text':
-                        if (input) {
-                            input += '\n\n';
-                        }
-                        if (hasMultipleRoles) {
-                            input += `--${message.role.toUpperCase()}\n`;
-                        }
-                        input += message.content.text;
-                        break;
-                    case 'resource':
-                        if ('text' in message.content.resource) {
-                            await attachBlob(message.content.resource.mimeType, message.content.resource.text, message.content.resource.uri, true);
-                        }
-                        else {
-                            await attachBlob(message.content.resource.mimeType, message.content.resource.blob, message.content.resource.uri);
-                        }
-                        break;
-                    case 'image':
-                    case 'audio':
-                        await attachBlob(message.content.mimeType, message.content.data);
-                        break;
-                }
-            }
-            if (toAttach.length) {
-                chatWidget.attachmentModel.addContext(...toAttach);
-            }
-            replaceTextWith(input);
-        }
-        finally {
-            store.dispose();
-        }
-    }
-}
-registerAction2(StartParameterizedPromptAction);
-class ReferenceArgument {
-    constructor(widget, variable) {
-        this.widget = widget;
-        this.variable = variable;
-    }
-}
-let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
-    static { BuiltinDynamicCompletions_1 = this; }
-    static { this.addReferenceCommand = '_addReferenceCmd'; }
-    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}[\\w:-]*`, 'g')); }
-    constructor(historyService, workspaceContextService, searchService, labelService, languageFeaturesService, chatWidgetService, _chatEditingService, outlineService, editorService, configurationService, codeEditorService, chatAgentService, instantiationService) {
-        super();
-        this.historyService = historyService;
-        this.workspaceContextService = workspaceContextService;
-        this.searchService = searchService;
-        this.labelService = labelService;
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this._chatEditingService = _chatEditingService;
-        this.outlineService = outlineService;
-        this.editorService = editorService;
-        this.configurationService = configurationService;
-        this.codeEditorService = codeEditorService;
-        this.chatAgentService = chatAgentService;
-        this.instantiationService = instantiationService;
-        const fileWordPattern = ( new RegExp(`${chatVariableLeader}[^\\s]*`, 'g'));
-        this.registerVariableCompletions('fileAndFolder', async ({ widget, range }, token) => {
-            if (!widget.supportsFileReferences) {
-                return;
-            }
-            const result = { suggestions: [] };
-            if (widget.lockedAgentId) {
-                const agent = this.chatAgentService.getAgent(widget.lockedAgentId);
-                if (agent && !agent.capabilities?.supportsFileAttachments) {
-                    return result;
-                }
-            }
-            await this.addFileAndFolderEntries(widget, result, range, token);
-            return result;
-        }, fileWordPattern);
-        this.registerVariableCompletions('selection', ({ widget, range }, token) => {
-            if (!widget.supportsFileReferences) {
-                return;
-            }
-            if (widget.location === ChatAgentLocation.EditorInline) {
-                return;
-            }
-            const active = this.findActiveCodeEditor();
-            if (!isCodeEditor(active)) {
-                return;
-            }
-            const currentResource = active.getModel()?.uri;
-            const currentSelection = active.getSelection();
-            if (!currentSelection || !currentResource || currentSelection.isEmpty()) {
-                return;
-            }
-            const basename = this.labelService.getUriBasenameLabel(currentResource);
-            const text = `${chatVariableLeader}file:${basename}:${currentSelection.startLineNumber}-${currentSelection.endLineNumber}`;
-            const fullRangeText = `:${currentSelection.startLineNumber}:${currentSelection.startColumn}-${currentSelection.endLineNumber}:${currentSelection.endColumn}`;
-            const description = this.labelService.getUriLabel(currentResource, { relative: true }) + fullRangeText;
-            const result = { suggestions: [] };
-            result.suggestions.push({
-                label: { label: `${chatVariableLeader}selection`, description },
-                filterText: `${chatVariableLeader}selection`,
-                insertText: range.varWord?.endColumn === range.replace.endColumn ? `${text} ` : text,
-                range,
-                kind: CompletionItemKind.Text,
-                sortText: 'z',
-                command: {
-                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
-                            id: 'vscode.selection',
-                            isFile: true,
-                            range: { startLineNumber: range.replace.startLineNumber, startColumn: range.replace.startColumn, endLineNumber: range.replace.endLineNumber, endColumn: range.replace.startColumn + text.length },
-                            data: { range: currentSelection, uri: currentResource }
-                        }))]
-                }
-            });
-            return result;
-        });
-        this.registerVariableCompletions('symbol', ({ widget, range, position, model }, token) => {
-            if (!widget.supportsFileReferences) {
-                return null;
-            }
-            const result = { suggestions: [] };
-            const range2 = computeCompletionRanges(model, position, ( new RegExp(`${chatVariableLeader}[^\\s]*`, 'g')), true);
-            if (range2) {
-                this.addSymbolEntries(widget, result, range2, token);
-            }
-            return result;
-        });
-        this._register(CommandsRegistry.registerCommand(BuiltinDynamicCompletions_1.addReferenceCommand, (_services, arg) => {
-            assertType(arg instanceof ReferenceArgument);
-            return this.cmdAddReference(arg);
-        }));
-    }
-    findActiveCodeEditor() {
-        const codeEditor = this.codeEditorService.getActiveCodeEditor();
-        if (codeEditor) {
-            const model = codeEditor.getModel();
-            if (model?.uri.scheme === Schemas.vscodeNotebookCell) {
-                return undefined;
-            }
-            if (model) {
-                return codeEditor;
-            }
-        }
-        for (const codeOrDiffEditor of this.editorService.getVisibleTextEditorControls(EditorsOrder.MOST_RECENTLY_ACTIVE)) {
-            const codeEditor = getCodeEditor(codeOrDiffEditor);
-            if (!codeEditor) {
-                continue;
-            }
-            const model = codeEditor.getModel();
-            if (model) {
-                return codeEditor;
-            }
-        }
-        return undefined;
-    }
-    registerVariableCompletions(debugName, provider, wordPattern = BuiltinDynamicCompletions_1.VariableNameDef) {
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: `chatVarCompletions-${debugName}`,
-            triggerCharacters: [chatVariableLeader],
-            provideCompletionItems: async (model, position, context, token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget) {
-                    return;
-                }
-                const range = computeCompletionRanges(model, position, wordPattern, true);
-                if (range) {
-                    return provider({ model, position, widget, range, context }, token);
-                }
-                return;
-            }
-        }));
-    }
-    async addFileAndFolderEntries(widget, result, info, token) {
-        const makeCompletionItem = (resource, kind, description, boostPriority) => {
-            const basename = this.labelService.getUriBasenameLabel(resource);
-            const text = `${chatVariableLeader}file:${basename}`;
-            const uriLabel = this.labelService.getUriLabel(resource, { relative: true });
-            const labelDescription = description
-                ? ( localize(5841, '{0} ({1})', uriLabel, description))
-                : uriLabel;
-            const sortText = boostPriority ? ' ' : '!';
-            return {
-                label: { label: basename, description: labelDescription },
-                filterText: `${chatVariableLeader}${basename}`,
-                insertText: info.varWord?.endColumn === info.replace.endColumn ? `${text} ` : text,
-                range: info,
-                kind: kind === FileKind.FILE ? CompletionItemKind.File : CompletionItemKind.Folder,
-                sortText,
-                command: {
-                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
-                            id: ( resource.toString()),
-                            isFile: kind === FileKind.FILE,
-                            isDirectory: kind === FileKind.FOLDER,
-                            range: { startLineNumber: info.replace.startLineNumber, startColumn: info.replace.startColumn, endLineNumber: info.replace.endLineNumber, endColumn: info.replace.startColumn + text.length },
-                            data: resource
-                        }))]
-                }
-            };
-        };
-        let pattern;
-        if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) {
-            pattern = info.varWord.word.toLowerCase().slice(1);
-        }
-        const seen = ( new ResourceSet());
-        const len = result.suggestions.length;
-        for (const [i, item] of this.historyService.getHistory().entries()) {
-            const resource = isDiffEditorInput(item) ? item.modified.resource : item.resource;
-            if (!resource || ( seen.has(resource)) || !this.instantiationService.invokeFunction(accessor => isSupportedChatFileScheme(accessor, resource.scheme))) {
-                continue;
-            }
-            if (pattern) {
-                const basename = this.labelService.getUriBasenameLabel(resource).toLowerCase();
-                if (!isPatternInWord(pattern, 0, pattern.length, basename, 0, basename.length)) {
-                    continue;
-                }
-            }
-            seen.add(resource);
-            const newLen = result.suggestions.push(makeCompletionItem(resource, FileKind.FILE, i === 0 ? ( localize(5842, 'Active file')) : undefined, i === 0));
-            if (newLen - len >= 5) {
-                break;
-            }
-        }
-        if (widget.input.currentModeKind !== ChatModeKind.Ask && widget.viewModel && widget.viewModel.model.editingSession) {
-            const relatedFiles = (await raceTimeout(this._chatEditingService.getRelatedFiles(widget.viewModel.sessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, token), 200)) ?? [];
-            for (const relatedFileGroup of relatedFiles) {
-                for (const relatedFile of relatedFileGroup.files) {
-                    if (!( seen.has(relatedFile.uri))) {
-                        seen.add(relatedFile.uri);
-                        result.suggestions.push(makeCompletionItem(relatedFile.uri, FileKind.FILE, relatedFile.description));
-                    }
-                }
-            }
-        }
-        if (pattern) {
-            const cacheKey = this.updateCacheKey();
-            const workspaces = ( this.workspaceContextService.getWorkspace().folders.map(folder => folder.uri));
-            for (const workspace of workspaces) {
-                const { folders, files } = await searchFilesAndFolders(workspace, pattern, true, token, cacheKey.key, this.configurationService, this.searchService);
-                for (const file of files) {
-                    if (!( seen.has(file))) {
-                        result.suggestions.push(makeCompletionItem(file, FileKind.FILE));
-                        seen.add(file);
-                    }
-                }
-                for (const folder of folders) {
-                    if (!( seen.has(folder))) {
-                        result.suggestions.push(makeCompletionItem(folder, FileKind.FOLDER));
-                        seen.add(folder);
-                    }
-                }
-            }
-        }
-        result.incomplete = true;
-    }
-    addSymbolEntries(widget, result, info, token) {
-        const timeoutMs = 100;
-        const stopwatch = ( new StopWatch());
-        const makeSymbolCompletionItem = (symbolItem, pattern) => {
-            const text = `${chatVariableLeader}sym:${symbolItem.name}`;
-            const resource = symbolItem.location.uri;
-            const uriLabel = this.labelService.getUriLabel(resource, { relative: true });
-            const sortText = pattern ? '{'  : '|' ;
-            return {
-                label: { label: symbolItem.name, description: uriLabel },
-                filterText: `${chatVariableLeader}${symbolItem.name}`,
-                insertText: info.varWord?.endColumn === info.replace.endColumn ? `${text} ` : text,
-                range: info,
-                kind: SymbolKinds.toCompletionKind(symbolItem.kind),
-                sortText,
-                command: {
-                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
-                            id: `vscode.symbol/${JSON.stringify(symbolItem.location)}`,
-                            fullName: symbolItem.name,
-                            range: { startLineNumber: info.replace.startLineNumber, startColumn: info.replace.startColumn, endLineNumber: info.replace.endLineNumber, endColumn: info.replace.startColumn + text.length },
-                            data: symbolItem.location,
-                            icon: SymbolKinds.toIcon(symbolItem.kind)
-                        }))]
-                }
-            };
-        };
-        let pattern;
-        if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) {
-            pattern = info.varWord.word.toLowerCase().slice(1);
-        }
-        const symbolsToAdd = [];
-        for (const outlineModel of this.outlineService.getCachedModels()) {
-            const symbols = outlineModel.asListOfDocumentSymbols();
-            for (const symbol of symbols) {
-                symbolsToAdd.push({ symbol, uri: outlineModel.uri });
-            }
-        }
-        let timedOut = false;
-        for (const symbol of symbolsToAdd) {
-            if (stopwatch.elapsed() > timeoutMs || token.isCancellationRequested) {
-                timedOut = true;
-                break;
-            }
-            result.suggestions.push(makeSymbolCompletionItem({ ...symbol.symbol, location: { uri: symbol.uri, range: symbol.symbol.range } }, pattern ?? ''));
-        }
-        result.incomplete = !!pattern || timedOut;
-    }
-    updateCacheKey() {
-        if (this.cacheKey && Date.now() - this.cacheKey.time > 60000) {
-            this.searchService.clearCache(this.cacheKey.key);
-            this.cacheKey = undefined;
-        }
-        if (!this.cacheKey) {
-            this.cacheKey = {
-                key: generateUuid(),
-                time: Date.now()
-            };
-        }
-        this.cacheKey.time = Date.now();
-        return this.cacheKey;
-    }
-    cmdAddReference(arg) {
-        arg.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference(arg.variable);
-    }
-};
-BuiltinDynamicCompletions = BuiltinDynamicCompletions_1 = ( __decorate([
-    ( __param(0, IHistoryService)),
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, ISearchService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, ILanguageFeaturesService)),
-    ( __param(5, IChatWidgetService)),
-    ( __param(6, IChatEditingService)),
-    ( __param(7, IOutlineModelService)),
-    ( __param(8, IEditorService)),
-    ( __param(9, IConfigurationService)),
-    ( __param(10, ICodeEditorService)),
-    ( __param(11, IChatAgentService)),
-    ( __param(12, IInstantiationService))
-], BuiltinDynamicCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinDynamicCompletions, LifecyclePhase.Eventually);
-function computeCompletionRanges(model, position, reg, onlyOnWordStart = false) {
-    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
-    if (!varWord && model.getWordUntilPosition(position).word) {
-        return;
-    }
-    if (!varWord && position.column > 1) {
-        const textBefore = model.getValueInRange(( new Range(
-            position.lineNumber,
-            position.column - 1,
-            position.lineNumber,
-            position.column
-        )));
-        if (textBefore !== ' ') {
-            return;
-        }
-    }
-    if (varWord && onlyOnWordStart) {
-        const wordBefore = model.getWordUntilPosition({ lineNumber: position.lineNumber, column: varWord.startColumn });
-        if (wordBefore.word) {
-            return;
-        }
-    }
-    let insert;
-    let replace;
-    if (!varWord) {
-        insert = replace = Range.fromPositions(position);
-    }
-    else {
-        insert = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            position.column
-        ));
-        replace = ( new Range(
-            position.lineNumber,
-            varWord.startColumn,
-            position.lineNumber,
-            varWord.endColumn
-        ));
-    }
-    return { insert, replace, varWord };
-}
-function isEmptyUpToCompletionWord(model, rangeResult) {
-    const startToCompletionWordStart = ( new Range(1, 1, rangeResult.replace.startLineNumber, rangeResult.replace.startColumn));
-    return !!model.getValueInRange(startToCompletionWordStart).match(/^\s*$/);
-}
-let ToolCompletions = class ToolCompletions extends Disposable {
-    static { ToolCompletions_1 = this; }
-    static { this.VariableNameDef = ( new RegExp(`(?<=^|\\s)${chatVariableLeader}\\w*`, 'g')); }
-    constructor(languageFeaturesService, chatWidgetService, chatAgentService) {
-        super();
-        this.languageFeaturesService = languageFeaturesService;
-        this.chatWidgetService = chatWidgetService;
-        this.chatAgentService = chatAgentService;
-        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
-            _debugDisplayName: 'chatVariables',
-            triggerCharacters: [chatVariableLeader],
-            provideCompletionItems: async (model, position, _context, _token) => {
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget) {
-                    return null;
-                }
-                if (widget.lockedAgentId) {
-                    const agent = this.chatAgentService.getAgent(widget.lockedAgentId);
-                    if (agent && !agent.capabilities?.supportsToolAttachments) {
-                        return null;
-                    }
-                }
-                const range = computeCompletionRanges(model, position, ToolCompletions_1.VariableNameDef, true);
-                if (!range) {
-                    return null;
-                }
-                const usedNames = ( new Set());
-                for (const part of widget.parsedInput.parts) {
-                    if (part instanceof ChatRequestToolPart) {
-                        usedNames.add(part.toolName);
-                    }
-                    else if (part instanceof ChatRequestToolSetPart) {
-                        usedNames.add(part.name);
-                    }
-                }
-                const suggestions = [];
-                const iter = widget.input.selectedToolsModel.entriesMap.get();
-                for (const [item, enabled] of iter) {
-                    if (!enabled) {
-                        continue;
-                    }
-                    let detail;
-                    let documentation;
-                    let name;
-                    if (item instanceof ToolSet) {
-                        detail = item.description;
-                        name = item.referenceName;
-                    }
-                    else {
-                        const source = item.source;
-                        detail = ( localize(5843, "{0}: {1}", source.label, item.displayName));
-                        name = item.toolReferenceName ?? item.displayName;
-                        documentation = item.userDescription ?? item.modelDescription;
-                    }
-                    if (( usedNames.has(name))) {
-                        continue;
-                    }
-                    const withLeader = `${chatVariableLeader}${name}`;
-                    suggestions.push({
-                        label: withLeader,
-                        range,
-                        detail,
-                        documentation,
-                        insertText: withLeader + ' ',
-                        kind: CompletionItemKind.Tool,
-                        sortText: 'z',
-                    });
-                }
-                return { suggestions };
-            }
-        }));
-    }
-};
-ToolCompletions = ToolCompletions_1 = ( __decorate([
-    ( __param(0, ILanguageFeaturesService)),
-    ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatAgentService))
-], ToolCompletions));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ToolCompletions, LifecyclePhase.Eventually);
-
-export { computeCompletionRanges };