codemirror-languageserver 1.15.0 → 1.17.0

package/dist/completion.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@codemirror/state';
+export declare const autocompletion: () => Extension;

package/dist/definition.d.ts

@@ -1,4 +1,8 @@
 import { Command, KeyBinding } from '@codemirror/view';
 export declare const jumpToDefinition: Command;
 export declare const jumpToDefinitionPos: (pos: number) => Command;
+export declare const jumpToDeclaration: Command;
+export declare const jumpToDeclarationPos: (pos: number) => Command;
+export declare const jumpToTypeDefinition: Command;
+export declare const jumpToTypeDefinitionPos: (pos: number) => Command;
 export declare const jumpToDefinitionKeymap: readonly KeyBinding[];

package/dist/hover.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@codemirror/state';
+export declare const hoverTooltip: () => Extension;

package/dist/index.d.ts

@@ -1,2 +1,15 @@
-export { LanguageServerClient, languageServerPlugin, languageServer, languageServerWithTransport, } from './plugin';
+export { LanguageServerClient, languageServerPlugin } from './plugin';
 export { jumpToDefinition, jumpToDefinitionPos, jumpToDefinitionKeymap, } from './definition';
+export { PyrightInitializationOptions, RustAnalyzerInitializationOptions, TypeScriptInitializationOptions, ESLintInitializationOptions, ClangdInitializationOptions, GoplsInitializationOptions, } from './initialization';
+import { LanguageServerClient } from './plugin';
+import type { LanguageServerClientOptions, LanguageServerBaseOptions } from './plugin';
+interface LanguageServerOptions<InitializationOptions = unknown> extends LanguageServerClientOptions<InitializationOptions> {
+    client?: LanguageServerClient<InitializationOptions>;
+    allowHTMLContent?: boolean;
+}
+interface LanguageServerWebsocketOptions<InitializationOptions = unknown> extends LanguageServerBaseOptions {
+    serverUri: `ws://${string}` | `wss://${string}`;
+    initializationOptions?: InitializationOptions;
+}
+export declare function languageServer<InitializationOptions = unknown>(options: LanguageServerWebsocketOptions<InitializationOptions>): import("@codemirror/state").Extension[];
+export declare function languageServerWithTransport<InitializationOptions = unknown>(options: LanguageServerOptions<InitializationOptions>): import("@codemirror/state").Extension[];

package/dist/index.js

@@ -1,7 +1,7 @@
-import { insertCompletionText, autocompletion } from '@codemirror/autocomplete';
+import { insertCompletionText, autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
 import { Facet } from '@codemirror/state';
-import { ViewPlugin, hoverTooltip } from '@codemirror/view';
+import { ViewPlugin, hoverTooltip as hoverTooltip$1, EditorView, keymap } from '@codemirror/view';
 import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
 import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind } from 'vscode-languageserver-protocol';
 import { marked } from 'marked';
@@ -28,11 +28,11 @@ const timeout = 10000;
 const changesDelay = 500;
 const CompletionItemKindMap = Object.fromEntries(Object.entries(CompletionItemKind).map(([key, value]) => [value, key]));
 const useLast = (values) => values.reduce((_, v) => v, '');
-const client = Facet.define({
+Facet.define({
     combine: useLast,
 });
-const documentUri = Facet.define({ combine: useLast });
-const languageId = Facet.define({ combine: useLast });
+Facet.define({ combine: useLast });
+Facet.define({ combine: useLast });
 class LanguageServerClient {
     constructor(options) {
         this.options = options;
@@ -70,7 +70,7 @@ class LanguageServerClient {
                 textDocument: {
                     hover: {
                         dynamicRegistration: true,
-                        contentFormat: ['plaintext', 'markdown'],
+                        contentFormat: ['markdown', 'plaintext'],
                     },
                     moniker: {},
                     synchronization: {
@@ -84,16 +84,19 @@ class LanguageServerClient {
                         completionItem: {
                             snippetSupport: false,
                             commitCharactersSupport: true,
-                            documentationFormat: ['plaintext', 'markdown'],
+                            documentationFormat: ['markdown', 'plaintext'],
                             deprecatedSupport: false,
                             preselectSupport: false,
+                            resolveSupport: {
+                                properties: ['detail', 'documentation'],
+                            },
                         },
                         contextSupport: true,
                     },
                     signatureHelp: {
                         dynamicRegistration: true,
                         signatureInformation: {
-                            documentationFormat: ['plaintext', 'markdown'],
+                            documentationFormat: ['markdown', 'plaintext'],
                         },
                     },
                     declaration: {
@@ -149,6 +152,15 @@ class LanguageServerClient {
     async textDocumentDefinition(params) {
         return await this.request('textDocument/definition', params, timeout);
     }
+    async textDocumentDeclaration(params) {
+        return await this.request('textDocument/declaration', params, timeout);
+    }
+    async textDocumentTypeDefinition(params) {
+        return await this.request('textDocument/typeDefinition', params, timeout);
+    }
+    async completionItemResolve(params) {
+        return await this.request('completionItem/resolve', params, timeout);
+    }
     attachPlugin(plugin) {
         this.plugins.push(plugin);
     }
@@ -175,12 +187,12 @@ class LanguageServerClient {
     }
 }
 class LanguageServerPlugin {
-    constructor(view, allowHTMLContent) {
+    constructor(view, { client, documentUri, languageId, allowHTMLContent, }) {
         this.view = view;
+        this.client = client;
+        this.documentUri = documentUri;
+        this.languageId = languageId;
         this.allowHTMLContent = allowHTMLContent;
-        this.client = this.view.state.facet(client);
-        this.documentUri = this.view.state.facet(documentUri);
-        this.languageId = this.view.state.facet(languageId);
         this.documentVersion = 0;
         this.changesTimeout = 0;
         this.client.attachPlugin(this);
@@ -322,7 +334,8 @@ class LanguageServerPlugin {
                 });
             }
         }
-        const options = items.map(({ detail, label, kind, textEdit, documentation, additionalTextEdits, }) => {
+        const options = items.map((item) => {
+            const { detail, label, kind, textEdit, documentation, additionalTextEdits, } = item;
             const completion = {
                 label,
                 detail,
@@ -360,20 +373,26 @@ class LanguageServerPlugin {
                 },
                 type: kind && CompletionItemKindMap[kind].toLowerCase(),
             };
-            if (documentation) {
-                completion.info = async () => {
-                    const dom = document.createElement('div');
-                    dom.classList.add('documentation');
-                    if (this.allowHTMLContent) {
-                        dom.innerHTML = await formatContents(documentation);
-                    }
-                    else {
-                        dom.textContent =
-                            await formatContents(documentation);
-                    }
-                    return dom;
-                };
-            }
+            completion.info = async () => {
+                var _a;
+                let { documentation } = item;
+                if (!documentation &&
+                    ((_a = this.client.capabilities.completionProvider) === null || _a === void 0 ? void 0 : _a.resolveProvider)) {
+                    const resolvedItem = await this.client.completionItemResolve(item);
+                    documentation = resolvedItem.documentation;
+                }
+                if (!documentation)
+                    return null;
+                const dom = document.createElement('div');
+                dom.classList.add('documentation');
+                if (this.allowHTMLContent) {
+                    dom.innerHTML = await formatContents(documentation);
+                }
+                else {
+                    dom.textContent = await formatContents(documentation);
+                }
+                return dom;
+            };
             return completion;
         });
         return {
@@ -382,12 +401,11 @@ class LanguageServerPlugin {
             filter: false,
         };
     }
-    async requestDefinition(view, { line, character }) {
-        if (!this.client.ready ||
-            !this.client.capabilities.definitionProvider) {
+    async requestLocation(view, { line, character }, capability, method) {
+        if (!this.client.ready || !this.client.capabilities[capability]) {
             return null;
         }
-        const result = await this.client.textDocumentDefinition({
+        const result = await this.client[method]({
             textDocument: { uri: this.documentUri },
             position: { line, character },
         });
@@ -404,6 +422,7 @@ class LanguageServerPlugin {
                     anchor: posToOffset(view.state.doc, range.start),
                     head: posToOffset(view.state.doc, range.end),
                 },
+                scrollIntoView: true,
             }));
         }
         return {
@@ -411,6 +430,15 @@ class LanguageServerPlugin {
             range,
         };
     }
+    async requestDefinition(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'definitionProvider', 'textDocumentDefinition');
+    }
+    async requestDeclaration(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'declarationProvider', 'textDocumentDeclaration');
+    }
+    async requestTypeDefinition(view, { line, character }) {
+        return this.requestLocation(view, { line, character }, 'typeDefinitionProvider', 'textDocumentTypeDefinition');
+    }
     processNotification(notification) {
         try {
             switch (notification.method) {
@@ -455,58 +483,6 @@ class LanguageServerPlugin {
     }
 }
 const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
-function languageServer(options) {
-    const serverUri = options.serverUri;
-    const { serverUri: _, ...optionsWithoutServerUri } = options;
-    return languageServerWithTransport({
-        ...optionsWithoutServerUri,
-        transport: new WebSocketTransport(serverUri),
-    });
-}
-function languageServerWithTransport(options) {
-    return [
-        client.of(options.client ||
-            new LanguageServerClient({
-                ...options,
-                autoClose: true,
-            })),
-        documentUri.of(options.documentUri),
-        languageId.of(options.languageId),
-        languageServerPlugin.of(options.allowHTMLContent),
-        hoverTooltip((view, pos) => {
-            var _a;
-            const plugin = view.plugin(languageServerPlugin);
-            return ((_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null);
-        }),
-        autocompletion({
-            override: [
-                async (context) => {
-                    var _a, _b, _c;
-                    const { state, pos, explicit, view } = context;
-                    const plugin = view.plugin(languageServerPlugin);
-                    if (plugin == null)
-                        return null;
-                    const line = state.doc.lineAt(pos);
-                    let trigKind = CompletionTriggerKind.Invoked;
-                    let trigChar;
-                    if (!explicit &&
-                        ((_c = (_b = (_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.completionProvider) === null || _b === void 0 ? void 0 : _b.triggerCharacters) === null || _c === void 0 ? void 0 : _c.includes(line.text[pos - line.from - 1]))) {
-                        trigKind = CompletionTriggerKind.TriggerCharacter;
-                        trigChar = line.text[pos - line.from - 1];
-                    }
-                    if (trigKind === CompletionTriggerKind.Invoked &&
-                        !context.matchBefore(/\w+$/)) {
-                        return null;
-                    }
-                    return await plugin.requestCompletion(context, offsetToPos(state.doc, pos), {
-                        triggerCharacter: trigChar,
-                        triggerKind: trigKind,
-                    });
-                },
-            ],
-        }),
-    ];
-}
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
         let value = contents.value;
@@ -554,17 +530,104 @@ function isLSPMarkupContent(contents) {
     return contents.kind !== undefined;
 }
 
-function jumpTo(view, pos) {
+function requestDefinition(view, pos) {
     const plugin = view.plugin(languageServerPlugin);
     if (!plugin)
         return false;
     plugin.requestDefinition(view, offsetToPos(view.state.doc, pos));
     return true;
 }
-const jumpToDefinition = (view) => jumpTo(view, view.state.selection.main.head);
-const jumpToDefinitionPos = (pos) => (view) => jumpTo(view, pos);
+function requestTypeDefinition(view, pos) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    plugin.requestTypeDefinition(view, offsetToPos(view.state.doc, pos));
+    return true;
+}
+const jumpToDefinition = (view) => requestDefinition(view, view.state.selection.main.head);
+const jumpToDefinitionPos = (pos) => (view) => requestDefinition(view, pos);
+const jumpToTypeDefinition = (view) => requestTypeDefinition(view, view.state.selection.main.head);
+const jumpToTypeDefinitionPos = (pos) => (view) => requestTypeDefinition(view, pos);
 const jumpToDefinitionKeymap = [
     { key: 'F12', run: jumpToDefinition, preventDefault: true },
+    { key: 'Mod-F12', run: jumpToTypeDefinition, preventDefault: true },
 ];
 
+const hoverTooltip = () => hoverTooltip$1((view, pos) => {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    return ((_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null);
+});
+
+const autocompletion = () => autocompletion$1({
+    override: [
+        async (context) => {
+            var _a, _b, _c;
+            const { state, pos, explicit, view } = context;
+            const plugin = view.plugin(languageServerPlugin);
+            if (plugin == null)
+                return null;
+            const line = state.doc.lineAt(pos);
+            let trigKind = CompletionTriggerKind.Invoked;
+            let trigChar;
+            if (!explicit &&
+                ((_c = (_b = (_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.completionProvider) === null || _b === void 0 ? void 0 : _b.triggerCharacters) === null || _c === void 0 ? void 0 : _c.includes(line.text[pos - line.from - 1]))) {
+                trigKind = CompletionTriggerKind.TriggerCharacter;
+                trigChar = line.text[pos - line.from - 1];
+            }
+            if (trigKind === CompletionTriggerKind.Invoked &&
+                !context.matchBefore(/\w+$/)) {
+                return null;
+            }
+            return await plugin.requestCompletion(context, offsetToPos(state.doc, pos), {
+                triggerCharacter: trigChar,
+                triggerKind: trigKind,
+            });
+        },
+    ],
+});
+
+const mouseHandler = () => EditorView.domEventHandlers({
+    mousedown: (event, view) => {
+        if (!event.ctrlKey && !event.metaKey)
+            return;
+        const pos = view.posAtCoords({
+            x: event.clientX,
+            y: event.clientY,
+        });
+        const ok = (event.shiftKey
+            ? jumpToTypeDefinitionPos(pos)
+            : jumpToDefinitionPos(pos))(view);
+        if (ok)
+            event.preventDefault();
+    },
+});
+
+function languageServer(options) {
+    const serverUri = options.serverUri;
+    const { serverUri: _, ...optionsWithoutServerUri } = options;
+    return languageServerWithTransport({
+        ...optionsWithoutServerUri,
+        transport: new WebSocketTransport(serverUri),
+    });
+}
+function languageServerWithTransport(options) {
+    return [
+        languageServerPlugin.of({
+            client: options.client ||
+                new LanguageServerClient({
+                    ...options,
+                    autoClose: true,
+                }),
+            documentUri: options.documentUri,
+            languageId: options.languageId,
+            allowHTMLContent: options.allowHTMLContent,
+        }),
+        hoverTooltip(),
+        autocompletion(),
+        keymap.of([...jumpToDefinitionKeymap]),
+        mouseHandler(),
+    ];
+}
+
 export { LanguageServerClient, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };

package/dist/initialization.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Initialization options for Pyright language server
+ * @see https://github.com/microsoft/pyright/blob/main/docs/settings.md
+ */
+export interface PyrightInitializationOptions {
+    python?: {
+        pythonPath?: string;
+        venvPath?: string;
+        analysis?: {
+            autoSearchPaths?: boolean;
+            extraPaths?: string[];
+            diagnosticMode?: 'workspace' | 'openFilesOnly';
+            stubPath?: string;
+            typeshedPaths?: string[];
+            useLibraryCodeForTypes?: boolean;
+            typeCheckingMode?: 'off' | 'basic' | 'strict';
+            autoImportCompletions?: boolean;
+            indexing?: boolean;
+        };
+    };
+    reportMissingImports?: boolean;
+    reportMissingTypeStubs?: boolean;
+    reportMissingModuleSource?: boolean;
+    reportInvalidTypeVarUse?: boolean;
+    reportOptionalSubscript?: boolean;
+    reportOptionalMemberAccess?: boolean;
+    reportOptionalCall?: boolean;
+    reportOptionalIterable?: boolean;
+    reportOptionalContextManager?: boolean;
+    reportOptionalOperand?: boolean;
+    reportTypedDictNotRequiredAccess?: boolean;
+    reportPrivateImportUsage?: boolean;
+    reportConstantRedefinition?: boolean;
+    reportIncompatibleMethodOverride?: boolean;
+    reportIncompatibleVariableOverride?: boolean;
+    reportInconsistentConstructor?: boolean;
+}
+/**
+ * Initialization options for Rust Analyzer language server
+ * @see https://rust-analyzer.github.io/manual.html#configuration
+ */
+export interface RustAnalyzerInitializationOptions {
+    cargo?: {
+        buildScripts?: {
+            enable?: boolean;
+            invocationStrategy?: 'per_workspace' | 'once';
+            invocationLocation?: 'workspace' | 'root';
+        };
+        allTargets?: boolean;
+        noDefaultFeatures?: boolean;
+        allFeatures?: boolean;
+        features?: string[];
+        target?: string;
+        runBuildScripts?: boolean;
+        useRustcWrapperForBuildScripts?: boolean;
+    };
+    procMacro?: {
+        enable?: boolean;
+        ignored?: Record<string, string[]>;
+        server?: string;
+        attributes?: {
+            enable?: boolean;
+        };
+    };
+    diagnostics?: {
+        enable?: boolean;
+        disabled?: string[];
+        warningsAsHint?: string[];
+        warningsAsInfo?: string[];
+        remapPrefix?: Record<string, string>;
+        experimental?: {
+            enable?: boolean;
+        };
+    };
+    completion?: {
+        addCallArgumentSnippets?: boolean;
+        addCallParenthesis?: boolean;
+        postfix?: {
+            enable?: boolean;
+        };
+        autoimport?: {
+            enable?: boolean;
+        };
+        privateEditable?: {
+            enable?: boolean;
+        };
+    };
+    assist?: {
+        importGranularity?: 'preserve' | 'crate' | 'module' | 'item';
+        importEnforceGranularity?: boolean;
+        importPrefix?: 'plain' | 'by_self' | 'by_crate';
+        allowMergingIntoGlobImports?: boolean;
+    };
+    callInfo?: {
+        full?: boolean;
+    };
+    lens?: {
+        enable?: boolean;
+        run?: boolean;
+        debug?: boolean;
+        implementations?: boolean;
+        refs?: boolean;
+        methodReferences?: boolean;
+        references?: boolean;
+        enumVariantReferences?: boolean;
+    };
+    hover?: {
+        documentation?: boolean;
+        keywords?: boolean;
+        linksInHover?: boolean;
+        memoryLayout?: {
+            enable?: boolean;
+        };
+    };
+    workspace?: {
+        symbol?: {
+            search?: {
+                scope?: 'workspace' | 'workspace_and_dependencies';
+                kind?: 'only_types' | 'all_symbols';
+            };
+        };
+    };
+}
+/**
+ * Initialization options for TypeScript/JavaScript language server
+ * @see https://github.com/typescript-language-server/typescript-language-server
+ */
+export interface TypeScriptInitializationOptions {
+    hostInfo?: string;
+    npmLocation?: string;
+    globalPlugins?: string[];
+    pluginProbeLocations?: string[];
+    preferences?: {
+        includePackageJsonAutoImports?: 'auto' | 'on' | 'off';
+        providePrefixAndSuffixTextForRename?: boolean;
+        allowRenameOfImportPath?: boolean;
+        includeAutomaticOptionalChainCompletions?: boolean;
+        includeCompletionsForModuleExports?: boolean;
+        includeCompletionsForImportStatements?: boolean;
+        includeCompletionsWithSnippetText?: boolean;
+        includeCompletionsWithInsertText?: boolean;
+        allowIncompleteCompletions?: boolean;
+        importModuleSpecifier?: 'shortest' | 'relative' | 'absolute' | 'auto';
+        importModuleSpecifierEnding?: 'minimal' | 'index' | 'js';
+        allowTextChangesInNewFiles?: boolean;
+        lazyConfiguredProjectsFromExternalProject?: boolean;
+        providePrefixAndSuffixTextForQuickInfo?: boolean;
+        includeInlayParameterNameHints?: 'none' | 'literals' | 'all';
+        includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean;
+        includeInlayFunctionParameterTypeHints?: boolean;
+        includeInlayVariableTypeHints?: boolean;
+        includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean;
+        includeInlayPropertyDeclarationTypeHints?: boolean;
+        includeInlayFunctionLikeReturnTypeHints?: boolean;
+        includeInlayEnumMemberValueHints?: boolean;
+    };
+    locale?: string;
+    maxTsServerMemory?: number;
+    tsserver?: {
+        logLevel?: 'off' | 'terse' | 'normal' | 'requestTime' | 'verbose';
+        logVerbosity?: 'off' | 'terse' | 'normal' | 'requestTime' | 'verbose';
+        trace?: 'off' | 'messages' | 'verbose';
+        useSeparateSyntaxServer?: boolean;
+        enableTracing?: boolean;
+        path?: string;
+    };
+}
+/**
+ * Initialization options for ESLint language server
+ * @see https://github.com/Microsoft/vscode-eslint
+ */
+export interface ESLintInitializationOptions {
+    packageManager?: 'npm' | 'yarn' | 'pnpm';
+    nodePath?: string;
+    options?: Record<string, any>;
+    rules?: Record<string, any>;
+    rulesCustomizations?: Array<{
+        rule: string;
+        severity: 'downgrade' | 'upgrade' | 'info' | 'warn' | 'error' | 'off';
+    }>;
+    run?: 'onType' | 'onSave';
+    problems?: {
+        shortenToSingleLine?: boolean;
+    };
+    codeAction?: {
+        disableRuleComment?: {
+            enable?: boolean;
+            location?: 'separateLine' | 'sameLine';
+        };
+        showDocumentation?: {
+            enable?: boolean;
+        };
+    };
+    codeActionOnSave?: {
+        enable?: boolean;
+        mode?: 'all' | 'problems';
+    };
+    format?: {
+        enable?: boolean;
+    };
+    quiet?: boolean;
+    onIgnoredFiles?: 'off' | 'warn';
+    useESLintClass?: boolean;
+    experimental?: {
+        useFlatConfig?: boolean;
+    };
+    workingDirectory?: {
+        mode?: 'auto' | 'location';
+    };
+}
+/**
+ * Initialization options for Clangd language server
+ * @see https://clangd.llvm.org/config
+ */
+export interface ClangdInitializationOptions {
+    compilationDatabasePath?: string;
+    compilationDatabaseChanges?: Record<string, any>;
+    fallbackFlags?: string[];
+    clangdFileStatus?: boolean;
+    utf8?: boolean;
+    offsetEncoding?: ('utf-8' | 'utf-16' | 'utf-32')[];
+    index?: {
+        background?: 'Build' | 'Skip';
+        threads?: number;
+    };
+    completion?: {
+        detailedLabel?: boolean;
+        allScopes?: boolean;
+    };
+    hover?: {
+        showAKA?: boolean;
+    };
+    inlayHints?: {
+        enabled?: boolean;
+        parameterNames?: boolean;
+        deducedTypes?: boolean;
+        designators?: boolean;
+    };
+    semanticHighlighting?: boolean;
+    diagnostics?: {
+        unusedIncludes?: 'None' | 'Strict';
+        missingIncludes?: 'None' | 'Strict';
+        clangTidy?: boolean;
+        suppressAll?: boolean;
+    };
+}
+/**
+ * Initialization options for Gopls (Go language server)
+ * @see https://github.com/golang/tools/blob/master/gopls/doc/settings.md
+ */
+export interface GoplsInitializationOptions {
+    buildFlags?: string[];
+    env?: Record<string, string>;
+    directoryFilters?: string[];
+    templateExtensions?: string[];
+    memoryMode?: 'DegradeClosed' | 'Normal';
+    gofumpt?: boolean;
+    staticcheck?: boolean;
+    analyses?: Record<string, boolean>;
+    codelenses?: Record<string, boolean>;
+    usePlaceholders?: boolean;
+    completionBudget?: string;
+    diagnosticsDelay?: string;
+    experimentalPostfixCompletions?: boolean;
+    experimentalWorkspaceModule?: boolean;
+    experimentalTemplateSupport?: boolean;
+    semanticTokens?: boolean;
+    noSemanticString?: boolean;
+    noSemanticNumber?: boolean;
+    expandWorkspaceToModule?: boolean;
+    experimentalUseInvalidMetadata?: boolean;
+    hoverKind?: 'FullDocumentation' | 'NoDocumentation' | 'SingleLine' | 'Structured' | 'SynopsisDocumentation';
+    linkTarget?: string;
+    linksInHover?: boolean;
+    importShortcut?: 'Both' | 'Definition' | 'Link';
+    symbolMatcher?: 'CaseInsensitive' | 'CaseSensitive' | 'FastFuzzy' | 'Fuzzy';
+    symbolStyle?: 'Dynamic' | 'Full' | 'Package';
+    verboseOutput?: boolean;
+}

package/dist/mouse.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@codemirror/state';
+export declare const mouseHandler: () => Extension;