codemirror-languageserver 1.14.0 → 1.15.0

package/README.md

@@ -12,37 +12,48 @@ This plugin enables code completion, hover tooltips, and linter functionality by
 npm i codemirror-languageserver
 ```
 
-``` js
+```js
 import { languageServer } from 'codemirror-languageserver';
 
-const transport = new WebSocketTransport(serverUri)
+const transport = new WebSocketTransport(serverUri);
 
 var ls = languageServer({
-	// WebSocket server uri and other client options.
-	serverUri,
-	rootUri: 'file:///',
-
-	// Alternatively, to share the same client across multiple instances of this plugin.
-	client: new LanguageServerClient({
-		serverUri,
-		rootUri: 'file:///'
-	}),
-
-	documentUri: `file:///${filename}`,
-	languageId: 'cpp' // As defined at https://microsoft.github.io/language-server-protocol/specification#textDocumentItem.
+    // WebSocket server uri and other client options.
+    serverUri,
+    rootUri: 'file:///',
+
+    // Alternatively, to share the same client across multiple instances of this plugin.
+    client: new LanguageServerClient({
+        serverUri,
+        rootUri: 'file:///',
+    }),
+
+    documentUri: `file:///${filename}`,
+    languageId: 'cpp', // As defined at https://microsoft.github.io/language-server-protocol/specification#textDocumentItem.
 });
 
 var view = new EditorView({
-	state: EditorState.create({
-		extensions: [
-			// ...
-			ls,
-			// ...
-		]
-	})
+    state: EditorState.create({
+        extensions: [
+            // ...
+            ls,
+            // ...
+        ],
+    }),
 });
 ```
 
+### Using with Initialization Options
+
+The plugin includes built-in TypeScript definitions for popular language servers:
+
+-   `PyrightInitializationOptions` - Python (Pyright)
+-   `RustAnalyzerInitializationOptions` - Rust (rust-analyzer)
+-   `TypeScriptInitializationOptions` - TypeScript/JavaScript
+-   `ESLintInitializationOptions` - ESLint
+-   `ClangdInitializationOptions` - C/C++ (Clangd)
+-   `GoplsInitializationOptions` - Go (Gopls)
+
 ## Contributing
 
 Contributions are welcome.
@@ -51,7 +62,7 @@ Contributions are welcome.
 
 https://user-images.githubusercontent.com/348107/120141150-c6bb9180-c1fd-11eb-8ada-9b7b7a1e4ade.mp4
 
-- [Toph](https://toph.co): Competitive programming platform. Toph uses Language Server Plugin for CodeMirror 6 with its integrated code editor.
+-   [Toph](https://toph.co): Competitive programming platform. Toph uses Language Server Plugin for CodeMirror 6 with its integrated code editor.
 
 ## License
 

package/demo/demo.js

@@ -32,7 +32,11 @@ import {
 } from '@codemirror/autocomplete';
 import { lintKeymap } from '@codemirror/lint';
 import { cpp } from '@codemirror/lang-cpp';
-import { languageServer } from '../src';
+import {
+    languageServer,
+    jumpToDefinitionKeymap,
+    jumpToDefinitionPos,
+} from '../src';
 
 const tabSizeCompartment = new Compartment();
 
@@ -80,5 +84,17 @@ const view = new EditorView({
             documentUri: `file:///demo/main.cpp`,
             languageId: 'cpp',
         }),
+        keymap.of([...jumpToDefinitionKeymap]),
+        EditorView.domEventHandlers({
+            click: (event, view) => {
+                if (!event.ctrlKey && !event.metaKey) return;
+                const pos = view.posAtCoords({
+                    x: event.clientX,
+                    y: event.clientY,
+                });
+                const ok = jumpToDefinitionPos(pos)(view);
+                if (ok) event.preventDefault();
+            },
+        }),
     ],
 });

package/demo/dist/demo.js

@@ -39824,6 +39824,24 @@ d.options;
   R.parse;
   b.lex;
 
+function posToOffset(doc, pos) {
+    if (pos.line >= doc.lines) {
+        return;
+    }
+    const offset = doc.line(pos.line + 1).from + pos.character;
+    if (offset > doc.length) {
+        return;
+    }
+    return offset;
+}
+function offsetToPos(doc, offset) {
+    const line = doc.lineAt(offset);
+    return {
+        character: offset - line.from,
+        line: line.number - 1,
+    };
+}
+
 const timeout = 10000;
 const changesDelay = 500;
 const CompletionItemKindMap = Object.fromEntries(Object.entries(mainExports.CompletionItemKind).map(([key, value]) => [value, key]));
@@ -39835,6 +39853,7 @@ const documentUri = Facet.define({ combine: useLast });
 const languageId = Facet.define({ combine: useLast });
 class LanguageServerClient {
     constructor(options) {
+        this.options = options;
         this.rootUri = options.rootUri;
         this.workspaceFolders = options.workspaceFolders;
         this.autoClose = options.autoClose;
@@ -39862,8 +39881,9 @@ class LanguageServerClient {
         }
         this.initializePromise = this.initialize();
     }
-    async initialize() {
-        const { capabilities } = await this.request('initialize', {
+    getInitializeParams() {
+        var _a;
+        return {
             capabilities: {
                 textDocument: {
                     hover: {
@@ -39886,7 +39906,7 @@ class LanguageServerClient {
                             deprecatedSupport: false,
                             preselectSupport: false,
                         },
-                        contextSupport: false,
+                        contextSupport: true,
                     },
                     signatureHelp: {
                         dynamicRegistration: true,
@@ -39917,11 +39937,14 @@ class LanguageServerClient {
                     },
                 },
             },
-            initializationOptions: null,
+            initializationOptions: (_a = this.options.initializationOptions) !== null && _a !== void 0 ? _a : null,
             processId: null,
             rootUri: this.rootUri,
             workspaceFolders: this.workspaceFolders,
-        }, timeout * 3);
+        };
+    }
+    async initialize() {
+        const { capabilities } = await this.request('initialize', this.getInitializeParams(), timeout * 3);
         this.capabilities = capabilities;
         this.notify('initialized', {});
         this.ready = true;
@@ -39941,6 +39964,9 @@ class LanguageServerClient {
     async textDocumentCompletion(params) {
         return await this.request('textDocument/completion', params, timeout);
     }
+    async textDocumentDefinition(params) {
+        return await this.request('textDocument/definition', params, timeout);
+    }
     attachPlugin(plugin) {
         this.plugins.push(plugin);
     }
@@ -40174,6 +40200,35 @@ class LanguageServerPlugin {
             filter: false,
         };
     }
+    async requestDefinition(view, { line, character }) {
+        if (!this.client.ready ||
+            !this.client.capabilities.definitionProvider) {
+            return null;
+        }
+        const result = await this.client.textDocumentDefinition({
+            textDocument: { uri: this.documentUri },
+            position: { line, character },
+        });
+        if (!result)
+            return;
+        const location = Array.isArray(result) ? result[0] : result;
+        const uri = location.uri ||
+            location.targetUri;
+        const range = location.range ||
+            location.targetRange;
+        if (uri === this.documentUri) {
+            view.dispatch(view.state.update({
+                selection: {
+                    anchor: posToOffset(view.state.doc, range.start),
+                    head: posToOffset(view.state.doc, range.end),
+                },
+            }));
+        }
+        return {
+            uri,
+            range,
+        };
+    }
     processNotification(notification) {
         try {
             switch (notification.method) {
@@ -40217,34 +40272,38 @@ class LanguageServerPlugin {
         this.view.dispatch(setDiagnostics(this.view.state, diagnostics));
     }
 }
+const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 function languageServer(options) {
     const serverUri = options.serverUri;
-    delete options.serverUri;
+    const { serverUri: _, ...optionsWithoutServerUri } = options;
     return languageServerWithTransport({
-        ...options,
+        ...optionsWithoutServerUri,
         transport: new buildExports.WebSocketTransport(serverUri),
     });
 }
 function languageServerWithTransport(options) {
-    let plugin = null;
     return [
         client.of(options.client ||
-            new LanguageServerClient({ ...options, autoClose: true })),
+            new LanguageServerClient({
+                ...options,
+                autoClose: true,
+            })),
         documentUri.of(options.documentUri),
         languageId.of(options.languageId),
-        ViewPlugin.define((view) => (plugin = new LanguageServerPlugin(view, options.allowHTMLContent))),
+        languageServerPlugin.of(options.allowHTMLContent),
         hoverTooltip((view, pos) => {
             var _a;
-            return (_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null;
+            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;
-                    if (plugin == null) {
+                    const { state, pos, explicit, view } = context;
+                    const plugin = view.plugin(languageServerPlugin);
+                    if (plugin == null)
                         return null;
-                    }
-                    const { state, pos, explicit } = context;
                     const line = state.doc.lineAt(pos);
                     let trigKind = mainExports.CompletionTriggerKind.Invoked;
                     let trigChar;
@@ -40266,23 +40325,6 @@ function languageServerWithTransport(options) {
         }),
     ];
 }
-function posToOffset(doc, pos) {
-    if (pos.line >= doc.lines) {
-        return;
-    }
-    const offset = doc.line(pos.line + 1).from + pos.character;
-    if (offset > doc.length) {
-        return;
-    }
-    return offset;
-}
-function offsetToPos(doc, offset) {
-    const line = doc.lineAt(offset);
-    return {
-        character: offset - line.from,
-        line: line.number - 1,
-    };
-}
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
         let value = contents.value;
@@ -40313,10 +40355,11 @@ function prefixMatch(items) {
     const first = new Set();
     const rest = new Set();
     for (const item of items) {
-        const [initial, ...restStr] = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const text = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const initial = text[0];
         first.add(initial);
-        for (const char of restStr) {
-            rest.add(char);
+        for (let i = 1; i < text.length; i++) {
+            rest.add(text[i]);
         }
     }
     const source = toSet(first) + toSet(rest) + '*$';
@@ -40329,6 +40372,19 @@ function isLSPMarkupContent(contents) {
     return contents.kind !== undefined;
 }
 
+function jumpTo(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);
+const jumpToDefinitionKeymap = [
+    { key: 'F12', run: jumpToDefinition, preventDefault: true },
+];
+
 var tabSizeCompartment = new Compartment();
 new EditorView({
   doc: '#include <iostream>\n\nusing namespace std;\n\nint main() {\n\treturn 0;\n}\n',
@@ -40345,5 +40401,15 @@ new EditorView({
     }],
     documentUri: "file:///demo/main.cpp",
     languageId: 'cpp'
+  }), keymap.of(_toConsumableArray(jumpToDefinitionKeymap)), EditorView.domEventHandlers({
+    click: function click(event, view) {
+      if (!event.ctrlKey && !event.metaKey) return;
+      var pos = view.posAtCoords({
+        x: event.clientX,
+        y: event.clientY
+      });
+      var ok = jumpToDefinitionPos(pos)(view);
+      if (ok) event.preventDefault();
+    }
   })]
 });

package/dist/definition.d.ts

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

package/dist/index.d.ts

@@ -1,98 +1,2 @@
-import { EditorView, Tooltip } from '@codemirror/view';
-import { CompletionTriggerKind } from 'vscode-languageserver-protocol';
-import type { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
-import type { PluginValue, ViewUpdate } from '@codemirror/view';
-import { Transport } from '@open-rpc/client-js/build/transports/Transport';
-import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol';
-import type * as LSP from 'vscode-languageserver-protocol';
-interface LSPEventMap {
-    'textDocument/publishDiagnostics': LSP.PublishDiagnosticsParams;
-}
-type Notification = {
-    [key in keyof LSPEventMap]: {
-        jsonrpc: '2.0';
-        id?: null | undefined;
-        method: key;
-        params: LSPEventMap[key];
-    };
-}[keyof LSPEventMap];
-export declare class LanguageServerClient {
-    ready: boolean;
-    capabilities: LSP.ServerCapabilities<any>;
-    initializePromise: Promise<void>;
-    private rootUri;
-    private workspaceFolders;
-    private autoClose?;
-    private transport;
-    private requestManager;
-    private client;
-    private plugins;
-    constructor(options: LanguageServerClientOptions);
-    initialize(): Promise<void>;
-    close(): void;
-    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<LSP.DidOpenTextDocumentParams>;
-    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<LSP.DidChangeTextDocumentParams>;
-    textDocumentHover(params: LSP.HoverParams): Promise<LSP.Hover>;
-    textDocumentCompletion(params: LSP.CompletionParams): Promise<LSP.CompletionList | LSP.CompletionItem[]>;
-    attachPlugin(plugin: LanguageServerPlugin): void;
-    detachPlugin(plugin: LanguageServerPlugin): void;
-    private request;
-    private notify;
-    private processNotification;
-}
-declare class LanguageServerPlugin implements PluginValue {
-    private view;
-    private allowHTMLContent;
-    client: LanguageServerClient;
-    private documentUri;
-    private languageId;
-    private documentVersion;
-    private changesTimeout;
-    constructor(view: EditorView, allowHTMLContent: boolean);
-    update({ docChanged }: ViewUpdate): void;
-    destroy(): void;
-    initialize({ documentText }: {
-        documentText: string;
-    }): Promise<void>;
-    sendChange({ documentText }: {
-        documentText: string;
-    }): Promise<void>;
-    requestDiagnostics(view: EditorView): void;
-    requestHoverTooltip(view: EditorView, { line, character }: {
-        line: number;
-        character: number;
-    }): Promise<Tooltip | null>;
-    requestCompletion(context: CompletionContext, { line, character }: {
-        line: number;
-        character: number;
-    }, { triggerKind, triggerCharacter, }: {
-        triggerKind: CompletionTriggerKind;
-        triggerCharacter: string | undefined;
-    }): Promise<CompletionResult | null>;
-    processNotification(notification: Notification): void;
-    processDiagnostics(params: PublishDiagnosticsParams): void;
-}
-interface LanguageServerBaseOptions {
-    rootUri: string | null;
-    workspaceFolders: LSP.WorkspaceFolder[] | null;
-    documentUri: string;
-    languageId: string;
-}
-interface LanguageServerClientOptions extends LanguageServerBaseOptions {
-    transport: Transport;
-    autoClose?: boolean;
-}
-interface LanguageServerOptions extends LanguageServerClientOptions {
-    client?: LanguageServerClient;
-    allowHTMLContent?: boolean;
-}
-interface LanguageServerWebsocketOptions extends LanguageServerBaseOptions {
-    serverUri: `ws://${string}` | `wss://${string}`;
-}
-export declare function languageServer(options: LanguageServerWebsocketOptions): ({
-    extension: import("@codemirror/state").Extension;
-} | readonly import("@codemirror/state").Extension[])[];
-export declare function languageServerWithTransport(options: LanguageServerOptions): ({
-    extension: import("@codemirror/state").Extension;
-} | readonly import("@codemirror/state").Extension[])[];
-export {};
+export { LanguageServerClient, languageServerPlugin, languageServer, languageServerWithTransport, } from './plugin';
+export { jumpToDefinition, jumpToDefinitionPos, jumpToDefinitionKeymap, } from './definition';

package/dist/index.js

@@ -1,11 +1,29 @@
-import { autocompletion, insertCompletionText } from '@codemirror/autocomplete';
+import { insertCompletionText, autocompletion } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
 import { Facet } from '@codemirror/state';
 import { ViewPlugin, hoverTooltip } from '@codemirror/view';
 import { RequestManager, Client, WebSocketTransport } from '@open-rpc/client-js';
-import { CompletionItemKind, CompletionTriggerKind, DiagnosticSeverity } from 'vscode-languageserver-protocol';
+import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind } from 'vscode-languageserver-protocol';
 import { marked } from 'marked';
 
+function posToOffset(doc, pos) {
+    if (pos.line >= doc.lines) {
+        return;
+    }
+    const offset = doc.line(pos.line + 1).from + pos.character;
+    if (offset > doc.length) {
+        return;
+    }
+    return offset;
+}
+function offsetToPos(doc, offset) {
+    const line = doc.lineAt(offset);
+    return {
+        character: offset - line.from,
+        line: line.number - 1,
+    };
+}
+
 const timeout = 10000;
 const changesDelay = 500;
 const CompletionItemKindMap = Object.fromEntries(Object.entries(CompletionItemKind).map(([key, value]) => [value, key]));
@@ -17,6 +35,7 @@ const documentUri = Facet.define({ combine: useLast });
 const languageId = Facet.define({ combine: useLast });
 class LanguageServerClient {
     constructor(options) {
+        this.options = options;
         this.rootUri = options.rootUri;
         this.workspaceFolders = options.workspaceFolders;
         this.autoClose = options.autoClose;
@@ -44,8 +63,9 @@ class LanguageServerClient {
         }
         this.initializePromise = this.initialize();
     }
-    async initialize() {
-        const { capabilities } = await this.request('initialize', {
+    getInitializeParams() {
+        var _a;
+        return {
             capabilities: {
                 textDocument: {
                     hover: {
@@ -68,7 +88,7 @@ class LanguageServerClient {
                             deprecatedSupport: false,
                             preselectSupport: false,
                         },
-                        contextSupport: false,
+                        contextSupport: true,
                     },
                     signatureHelp: {
                         dynamicRegistration: true,
@@ -99,11 +119,14 @@ class LanguageServerClient {
                     },
                 },
             },
-            initializationOptions: null,
+            initializationOptions: (_a = this.options.initializationOptions) !== null && _a !== void 0 ? _a : null,
             processId: null,
             rootUri: this.rootUri,
             workspaceFolders: this.workspaceFolders,
-        }, timeout * 3);
+        };
+    }
+    async initialize() {
+        const { capabilities } = await this.request('initialize', this.getInitializeParams(), timeout * 3);
         this.capabilities = capabilities;
         this.notify('initialized', {});
         this.ready = true;
@@ -123,6 +146,9 @@ class LanguageServerClient {
     async textDocumentCompletion(params) {
         return await this.request('textDocument/completion', params, timeout);
     }
+    async textDocumentDefinition(params) {
+        return await this.request('textDocument/definition', params, timeout);
+    }
     attachPlugin(plugin) {
         this.plugins.push(plugin);
     }
@@ -356,6 +382,35 @@ class LanguageServerPlugin {
             filter: false,
         };
     }
+    async requestDefinition(view, { line, character }) {
+        if (!this.client.ready ||
+            !this.client.capabilities.definitionProvider) {
+            return null;
+        }
+        const result = await this.client.textDocumentDefinition({
+            textDocument: { uri: this.documentUri },
+            position: { line, character },
+        });
+        if (!result)
+            return;
+        const location = Array.isArray(result) ? result[0] : result;
+        const uri = location.uri ||
+            location.targetUri;
+        const range = location.range ||
+            location.targetRange;
+        if (uri === this.documentUri) {
+            view.dispatch(view.state.update({
+                selection: {
+                    anchor: posToOffset(view.state.doc, range.start),
+                    head: posToOffset(view.state.doc, range.end),
+                },
+            }));
+        }
+        return {
+            uri,
+            range,
+        };
+    }
     processNotification(notification) {
         try {
             switch (notification.method) {
@@ -399,34 +454,38 @@ class LanguageServerPlugin {
         this.view.dispatch(setDiagnostics(this.view.state, diagnostics));
     }
 }
+const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 function languageServer(options) {
     const serverUri = options.serverUri;
-    delete options.serverUri;
+    const { serverUri: _, ...optionsWithoutServerUri } = options;
     return languageServerWithTransport({
-        ...options,
+        ...optionsWithoutServerUri,
         transport: new WebSocketTransport(serverUri),
     });
 }
 function languageServerWithTransport(options) {
-    let plugin = null;
     return [
         client.of(options.client ||
-            new LanguageServerClient({ ...options, autoClose: true })),
+            new LanguageServerClient({
+                ...options,
+                autoClose: true,
+            })),
         documentUri.of(options.documentUri),
         languageId.of(options.languageId),
-        ViewPlugin.define((view) => (plugin = new LanguageServerPlugin(view, options.allowHTMLContent))),
+        languageServerPlugin.of(options.allowHTMLContent),
         hoverTooltip((view, pos) => {
             var _a;
-            return (_a = plugin === null || plugin === void 0 ? void 0 : plugin.requestHoverTooltip(view, offsetToPos(view.state.doc, pos))) !== null && _a !== void 0 ? _a : null;
+            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;
-                    if (plugin == null) {
+                    const { state, pos, explicit, view } = context;
+                    const plugin = view.plugin(languageServerPlugin);
+                    if (plugin == null)
                         return null;
-                    }
-                    const { state, pos, explicit } = context;
                     const line = state.doc.lineAt(pos);
                     let trigKind = CompletionTriggerKind.Invoked;
                     let trigChar;
@@ -448,23 +507,6 @@ function languageServerWithTransport(options) {
         }),
     ];
 }
-function posToOffset(doc, pos) {
-    if (pos.line >= doc.lines) {
-        return;
-    }
-    const offset = doc.line(pos.line + 1).from + pos.character;
-    if (offset > doc.length) {
-        return;
-    }
-    return offset;
-}
-function offsetToPos(doc, offset) {
-    const line = doc.lineAt(offset);
-    return {
-        character: offset - line.from,
-        line: line.number - 1,
-    };
-}
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
         let value = contents.value;
@@ -495,10 +537,11 @@ function prefixMatch(items) {
     const first = new Set();
     const rest = new Set();
     for (const item of items) {
-        const [initial, ...restStr] = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const text = ((_a = item.textEdit) === null || _a === void 0 ? void 0 : _a.newText) || item.label;
+        const initial = text[0];
         first.add(initial);
-        for (const char of restStr) {
-            rest.add(char);
+        for (let i = 1; i < text.length; i++) {
+            rest.add(text[i]);
         }
     }
     const source = toSet(first) + toSet(rest) + '*$';
@@ -511,4 +554,17 @@ function isLSPMarkupContent(contents) {
     return contents.kind !== undefined;
 }
 
-export { LanguageServerClient, languageServer, languageServerWithTransport };
+function jumpTo(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);
+const jumpToDefinitionKeymap = [
+    { key: 'F12', run: jumpToDefinition, preventDefault: true },
+];
+
+export { LanguageServerClient, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };

package/dist/plugin.d.ts

@@ -0,0 +1,407 @@
+import { EditorView, Tooltip, ViewPlugin } from '@codemirror/view';
+import { CompletionTriggerKind } from 'vscode-languageserver-protocol';
+import type { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+import type { PluginValue, ViewUpdate } from '@codemirror/view';
+import { Transport } from '@open-rpc/client-js/build/transports/Transport';
+import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol';
+import type * as LSP from 'vscode-languageserver-protocol';
+interface LSPRequestMap {
+    initialize: [LSP.InitializeParams, LSP.InitializeResult];
+    'textDocument/hover': [LSP.HoverParams, LSP.Hover];
+    'textDocument/completion': [
+        LSP.CompletionParams,
+        LSP.CompletionItem[] | LSP.CompletionList | null
+    ];
+    'textDocument/definition': [
+        LSP.DefinitionParams,
+        LSP.Location | LSP.Location[] | LSP.LocationLink[] | null
+    ];
+}
+interface LSPNotifyMap {
+    initialized: LSP.InitializedParams;
+    'textDocument/didChange': LSP.DidChangeTextDocumentParams;
+    'textDocument/didOpen': LSP.DidOpenTextDocumentParams;
+}
+interface LSPEventMap {
+    'textDocument/publishDiagnostics': LSP.PublishDiagnosticsParams;
+}
+type Notification = {
+    [key in keyof LSPEventMap]: {
+        jsonrpc: '2.0';
+        id?: null | undefined;
+        method: key;
+        params: LSPEventMap[key];
+    };
+}[keyof LSPEventMap];
+export declare class LanguageServerClient<InitializationOptions = unknown> {
+    ready: boolean;
+    capabilities: LSP.ServerCapabilities<any>;
+    initializePromise: Promise<void>;
+    private rootUri;
+    private workspaceFolders;
+    private autoClose?;
+    private transport;
+    private requestManager;
+    private client;
+    private plugins;
+    private options;
+    constructor(options: LanguageServerClientOptions<InitializationOptions>);
+    protected getInitializeParams(): LSP.InitializeParams;
+    initialize(): Promise<void>;
+    close(): void;
+    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<LSP.DidOpenTextDocumentParams>;
+    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<LSP.DidChangeTextDocumentParams>;
+    textDocumentHover(params: LSP.HoverParams): Promise<LSP.Hover>;
+    textDocumentCompletion(params: LSP.CompletionParams): Promise<LSP.CompletionList | LSP.CompletionItem[]>;
+    textDocumentDefinition(params: LSP.DefinitionParams): Promise<LSP.Location | LSP.Location[] | LSP.LocationLink[]>;
+    attachPlugin(plugin: LanguageServerPlugin): void;
+    detachPlugin(plugin: LanguageServerPlugin): void;
+    protected request<K extends keyof LSPRequestMap>(method: K, params: LSPRequestMap[K][0], timeout: number): Promise<LSPRequestMap[K][1]>;
+    protected notify<K extends keyof LSPNotifyMap>(method: K, params: LSPNotifyMap[K]): Promise<LSPNotifyMap[K]>;
+    protected processNotification(notification: Notification): void;
+}
+declare class LanguageServerPlugin implements PluginValue {
+    private view;
+    private allowHTMLContent;
+    client: LanguageServerClient;
+    private documentUri;
+    private languageId;
+    private documentVersion;
+    private changesTimeout;
+    constructor(view: EditorView, allowHTMLContent: boolean);
+    update({ docChanged }: ViewUpdate): void;
+    destroy(): void;
+    initialize({ documentText }: {
+        documentText: string;
+    }): Promise<void>;
+    sendChange({ documentText }: {
+        documentText: string;
+    }): Promise<void>;
+    requestDiagnostics(view: EditorView): void;
+    requestHoverTooltip(view: EditorView, { line, character }: {
+        line: number;
+        character: number;
+    }): Promise<Tooltip | null>;
+    requestCompletion(context: CompletionContext, { line, character }: {
+        line: number;
+        character: number;
+    }, { triggerKind, triggerCharacter, }: {
+        triggerKind: CompletionTriggerKind;
+        triggerCharacter: string | undefined;
+    }): Promise<CompletionResult | null>;
+    requestDefinition(view: EditorView, { line, character }: {
+        line: number;
+        character: number;
+    }): Promise<{
+        uri: string;
+        range: LSP.Range;
+    }>;
+    processNotification(notification: Notification): void;
+    processDiagnostics(params: PublishDiagnosticsParams): void;
+}
+export declare const languageServerPlugin: ViewPlugin<LanguageServerPlugin, boolean>;
+interface LanguageServerBaseOptions {
+    rootUri: string | null;
+    workspaceFolders: LSP.WorkspaceFolder[] | null;
+    documentUri: string;
+    languageId: string;
+}
+interface LanguageServerClientOptions<InitializationOptions = unknown> extends LanguageServerBaseOptions {
+    transport: Transport;
+    autoClose?: boolean;
+    initializationOptions?: InitializationOptions;
+}
+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>): ({
+    extension: import("@codemirror/state").Extension;
+} | readonly import("@codemirror/state").Extension[])[];
+export declare function languageServerWithTransport<InitializationOptions = unknown>(options: LanguageServerOptions<InitializationOptions>): ({
+    extension: import("@codemirror/state").Extension;
+} | readonly import("@codemirror/state").Extension[])[];
+/**
+ * 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;
+}
+export {};

package/dist/pos.d.ts

@@ -0,0 +1,9 @@
+import type { Text } from '@codemirror/state';
+export declare function posToOffset(doc: Text, pos: {
+    line: number;
+    character: number;
+}): number;
+export declare function offsetToPos(doc: Text, offset: number): {
+    character: number;
+    line: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "codemirror-languageserver",
-    "version": "1.14.0",
+    "version": "1.15.0",
     "description": "Language Server Plugin for CodeMirror 6",
     "main": "dist/index.js",
     "type": "module",