codemirror-languageserver 1.18.1 → 1.20.0

package/dist/index.js

@@ -1,10 +1,121 @@
-import { insertCompletionText, autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
 import { setDiagnostics } from '@codemirror/lint';
-import { Facet } from '@codemirror/state';
-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 { Facet, StateEffect, StateField } from '@codemirror/state';
+import { ViewPlugin, showPanel, hoverTooltip as hoverTooltip$1, EditorView, Decoration, keymap } from '@codemirror/view';
+import { CompletionItemKind, DiagnosticSeverity, CompletionTriggerKind, DocumentHighlightKind } from 'vscode-languageserver-protocol';
 import { marked } from 'marked';
+import { autocompletion as autocompletion$1 } from '@codemirror/autocomplete';
+
+/** A {@link Transport} that communicates over a browser-native WebSocket. */
+class WebSocketTransport {
+    constructor(uri) {
+        this.connection = new WebSocket(uri);
+    }
+    send(message) {
+        this.connection.send(message);
+    }
+    onMessage(callback) {
+        this.connection.addEventListener('message', (event) => {
+            callback(typeof event.data === 'string' ? event.data : '');
+        });
+    }
+    onClose(callback) {
+        this.connection.addEventListener('close', callback);
+    }
+    onError(callback) {
+        this.connection.addEventListener('error', () => {
+            callback(new Error('WebSocket error'));
+        });
+    }
+    close() {
+        this.connection.close();
+    }
+}
+class JSONRPCClient {
+    constructor(transport) {
+        this.nextId = 0;
+        this.pending = new Map();
+        this.notificationHandlers = [];
+        this.transport = transport;
+        this.ready = new Promise((resolve, reject) => {
+            if (transport instanceof WebSocketTransport) {
+                const ws = transport.connection;
+                if (ws.readyState === WebSocket.OPEN) {
+                    resolve();
+                }
+                else {
+                    ws.addEventListener('open', () => resolve());
+                    ws.addEventListener('error', () => reject(new Error('WebSocket connection failed')));
+                }
+            }
+            else {
+                resolve();
+            }
+        });
+        transport.onMessage((raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            if ('id' in msg && msg.id != null && this.pending.has(msg.id)) {
+                const pending = this.pending.get(msg.id);
+                this.pending.delete(msg.id);
+                clearTimeout(pending.timer);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message || 'JSON-RPC error'));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+            else if ('method' in msg) {
+                for (const handler of this.notificationHandlers) {
+                    handler(msg);
+                }
+            }
+        });
+    }
+    async request(req, timeout) {
+        await this.ready;
+        const id = this.nextId++;
+        const message = {
+            jsonrpc: '2.0',
+            id,
+            method: req.method,
+            params: req.params,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Request ${req.method} timed out`));
+            }, timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.transport.send(JSON.stringify(message));
+        });
+    }
+    async notify(notification) {
+        await this.ready;
+        const message = {
+            jsonrpc: '2.0',
+            method: notification.method,
+            params: notification.params,
+        };
+        this.transport.send(JSON.stringify(message));
+    }
+    onNotification(handler) {
+        this.notificationHandlers.push(handler);
+    }
+    close() {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Client closed'));
+        }
+        this.pending.clear();
+        this.transport.close();
+    }
+}
 
 function posToOffset(doc, pos) {
     if (pos.line >= doc.lines) {
@@ -46,6 +157,7 @@ function changeSetToEvents(doc, changes) {
 }
 
 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, '');
 Facet.define({
@@ -53,6 +165,12 @@ Facet.define({
 });
 Facet.define({ combine: useLast });
 Facet.define({ combine: useLast });
+/**
+ * Manages the JSON-RPC connection to a language server.
+ *
+ * Handles initialization, request/response routing, and notification dispatch.
+ * Can be shared across multiple editor instances via the `client` option.
+ */
 class LanguageServerClient {
     constructor(options) {
         this.options = options;
@@ -61,26 +179,19 @@ class LanguageServerClient {
         this.autoClose = options.autoClose;
         this.plugins = [];
         this.transport = options.transport;
-        this.requestManager = new RequestManager([this.transport]);
-        this.client = new Client(this.requestManager);
+        this.client = new JSONRPCClient(this.transport);
         this.client.onNotification((data) => {
+            if (data.method && data.id) {
+                // Server-to-client request: respond with null result.
+                // https://github.com/FurqanSoftware/codemirror-languageserver/issues/9
+                this.transport.send(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: data.id,
+                    result: null,
+                }));
+            }
             this.processNotification(data);
         });
-        const webSocketTransport = this.transport;
-        if (webSocketTransport && webSocketTransport.connection) {
-            // XXX(hjr265): Need a better way to do this. Relevant issue:
-            // https://github.com/FurqanSoftware/codemirror-languageserver/issues/9
-            webSocketTransport.connection.addEventListener('message', (message) => {
-                const data = JSON.parse(message.data);
-                if (data.method && data.id) {
-                    webSocketTransport.connection.send(JSON.stringify({
-                        jsonrpc: '2.0',
-                        id: data.id,
-                        result: null,
-                    }));
-                }
-            });
-        }
         this.initializePromise = this.initialize();
     }
     getInitializeParams() {
@@ -135,6 +246,19 @@ class LanguageServerClient {
                         dynamicRegistration: true,
                         linkSupport: true,
                     },
+                    documentHighlight: {
+                        dynamicRegistration: true,
+                    },
+                    formatting: {
+                        dynamicRegistration: true,
+                    },
+                    rangeFormatting: {
+                        dynamicRegistration: true,
+                    },
+                    rename: {
+                        dynamicRegistration: true,
+                        prepareSupport: true,
+                    },
                 },
                 workspace: {
                     didChangeConfiguration: {
@@ -143,16 +267,19 @@ class LanguageServerClient {
                 },
             },
             initializationOptions: (_a = this.options.initializationOptions) !== null && _a !== void 0 ? _a : null,
+            locale: this.options.locale,
             processId: null,
             rootUri: this.rootUri,
             workspaceFolders: this.workspaceFolders,
         };
     }
     async initialize() {
+        var _a, _b;
         const { capabilities } = await this.request('initialize', this.getInitializeParams(), timeout * 3);
         this.capabilities = capabilities;
         this.notify('initialized', {});
         this.ready = true;
+        (_b = (_a = this.options).onCapabilities) === null || _b === void 0 ? void 0 : _b.call(_a, capabilities);
     }
     close() {
         this.client.close();
@@ -178,6 +305,21 @@ class LanguageServerClient {
     async textDocumentTypeDefinition(params) {
         return await this.request('textDocument/typeDefinition', params, timeout);
     }
+    async textDocumentDocumentHighlight(params) {
+        return await this.request('textDocument/documentHighlight', params, timeout);
+    }
+    async textDocumentFormatting(params) {
+        return await this.request('textDocument/formatting', params, timeout);
+    }
+    async textDocumentRangeFormatting(params) {
+        return await this.request('textDocument/rangeFormatting', params, timeout);
+    }
+    async textDocumentPrepareRename(params) {
+        return await this.request('textDocument/prepareRename', params, timeout);
+    }
+    async textDocumentRename(params) {
+        return await this.request('textDocument/rename', params, timeout);
+    }
     async completionItemResolve(params) {
         return await this.request('completionItem/resolve', params, timeout);
     }
@@ -206,14 +348,19 @@ class LanguageServerClient {
         }
     }
 }
+/** Controls how document changes are sent to the language server. */
 var SynchronizationMethod;
 (function (SynchronizationMethod) {
+    /** Send the full document text on every change. */
     SynchronizationMethod["Full"] = "full";
+    /** Send only the changed ranges. More efficient for large documents. */
     SynchronizationMethod["Incremental"] = "incremental";
 })(SynchronizationMethod || (SynchronizationMethod = {}));
 class LanguageServerPlugin {
     constructor(view, { client, documentUri, languageId, allowHTMLContent, synchronizationMethod, }) {
         this.view = view;
+        this.changesTimeout = null;
+        this.pendingChanges = null;
         this.client = client;
         this.documentUri = documentUri;
         this.languageId = languageId;
@@ -230,20 +377,40 @@ class LanguageServerPlugin {
         if (!docChanged) {
             return;
         }
+        if (this.changesTimeout) {
+            clearTimeout(this.changesTimeout);
+        }
         switch (this.synchronizationMethod) {
             case SynchronizationMethod.Full:
-                this.sendChanges([
+                this.pendingChanges = [
                     {
                         text: this.view.state.doc.toString(),
                     },
-                ]);
+                ];
                 break;
             case SynchronizationMethod.Incremental:
-                this.sendChanges(changeSetToEvents(startState.doc, changes));
+                if (!this.pendingChanges) {
+                    this.pendingChanges = [];
+                }
+                this.pendingChanges.push(...changeSetToEvents(startState.doc, changes));
                 break;
         }
+        this.changesTimeout = setTimeout(() => {
+            this.changesTimeout = null;
+            if (this.pendingChanges) {
+                this.sendChanges(this.pendingChanges);
+                this.pendingChanges = null;
+            }
+        }, changesDelay);
     }
     destroy() {
+        if (this.changesTimeout) {
+            clearTimeout(this.changesTimeout);
+            if (this.pendingChanges) {
+                this.sendChanges(this.pendingChanges);
+                this.pendingChanges = null;
+            }
+        }
         this.client.detachPlugin(this);
     }
     async initialize({ documentText }) {
@@ -302,11 +469,12 @@ class LanguageServerPlugin {
         }
         const dom = document.createElement('div');
         dom.classList.add('documentation');
-        if (this.allowHTMLContent) {
-            dom.innerHTML = await formatContents(contents);
+        const formatted = await formatContents(contents);
+        if (formatted.isHTML || this.allowHTMLContent) {
+            dom.innerHTML = formatted.value;
         }
         else {
-            dom.textContent = await formatContents(contents);
+            dom.textContent = formatted.value;
         }
         return {
             pos,
@@ -366,56 +534,52 @@ class LanguageServerPlugin {
                 label,
                 detail,
                 apply(view, completion, from, to) {
+                    const changes = [];
                     if (isLSPTextEdit(textEdit)) {
-                        view.dispatch(insertCompletionText(view.state, textEdit.newText, posToOffset(view.state.doc, textEdit.range.start), posToOffset(view.state.doc, textEdit.range.end)));
+                        changes.push({
+                            from: posToOffset(view.state.doc, textEdit.range.start),
+                            to: Math.max(posToOffset(view.state.doc, textEdit.range.end), to),
+                            insert: textEdit.newText,
+                        });
                     }
                     else {
-                        view.dispatch(insertCompletionText(view.state, label, from, to));
-                    }
-                    if (!additionalTextEdits) {
-                        return;
+                        changes.push({
+                            from,
+                            to,
+                            insert: label,
+                        });
                     }
-                    additionalTextEdits
-                        .sort(({ range: { end: a } }, { range: { end: b } }) => {
-                        if (posToOffset(view.state.doc, a) <
-                            posToOffset(view.state.doc, b)) {
-                            return 1;
+                    if (additionalTextEdits) {
+                        for (const edit of additionalTextEdits) {
+                            changes.push({
+                                from: posToOffset(view.state.doc, edit.range.start),
+                                to: posToOffset(view.state.doc, edit.range.end),
+                                insert: edit.newText,
+                            });
                         }
-                        else if (posToOffset(view.state.doc, a) >
-                            posToOffset(view.state.doc, b)) {
-                            return -1;
-                        }
-                        return 0;
-                    })
-                        .forEach((textEdit) => {
-                        view.dispatch(view.state.update({
-                            changes: {
-                                from: posToOffset(view.state.doc, textEdit.range.start),
-                                to: posToOffset(view.state.doc, textEdit.range.end),
-                                insert: textEdit.newText,
-                            },
-                        }));
-                    });
+                    }
+                    view.dispatch(view.state.update({ changes }));
                 },
                 type: kind && CompletionItemKindMap[kind].toLowerCase(),
             };
             completion.info = async () => {
                 var _a;
-                let { documentation } = item;
-                if (!documentation &&
+                if (!item.documentation &&
                     ((_a = this.client.capabilities.completionProvider) === null || _a === void 0 ? void 0 : _a.resolveProvider)) {
                     const resolvedItem = await this.client.completionItemResolve(item);
-                    documentation = resolvedItem.documentation;
+                    item.documentation = resolvedItem.documentation;
                 }
+                const { documentation } = item;
                 if (!documentation)
                     return null;
                 const dom = document.createElement('div');
                 dom.classList.add('documentation');
-                if (this.allowHTMLContent) {
-                    dom.innerHTML = await formatContents(documentation);
+                const formatted = await formatContents(documentation);
+                if (formatted.isHTML || this.allowHTMLContent) {
+                    dom.innerHTML = formatted.value;
                 }
                 else {
-                    dom.textContent = await formatContents(documentation);
+                    dom.textContent = formatted.value;
                 }
                 return dom;
             };
@@ -511,19 +675,32 @@ class LanguageServerPlugin {
 const languageServerPlugin = ViewPlugin.fromClass(LanguageServerPlugin);
 async function formatContents(contents) {
     if (isLSPMarkupContent(contents)) {
-        let value = contents.value;
         if (contents.kind === 'markdown') {
-            value = await marked.parse(value);
+            return {
+                value: await marked.parse(contents.value),
+                isHTML: true,
+            };
         }
-        return value;
+        return { value: contents.value, isHTML: false };
     }
     else if (Array.isArray(contents)) {
-        return contents.map((c) => formatContents(c) + '\n\n').join('');
+        const parts = await Promise.all(contents.map((c) => formatContents(c)));
+        const isHTML = parts.some((p) => p.isHTML);
+        const value = parts
+            .map((p) => (isHTML && !p.isHTML ? escapeHTML(p.value) : p.value))
+            .join(isHTML ? '<br><br>' : '\n\n');
+        return { value, isHTML };
     }
     else if (typeof contents === 'string') {
-        return contents;
+        return { value: contents, isHTML: false };
     }
 }
+function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
 function toSet(chars) {
     let preamble = '';
     let flat = Array.from(chars).join('');
@@ -570,15 +747,256 @@ function requestTypeDefinition(view, pos) {
     plugin.requestTypeDefinition(view, offsetToPos(view.state.doc, pos));
     return true;
 }
+/** Command: jump to the definition of the symbol at the cursor. */
 const jumpToDefinition = (view) => requestDefinition(view, view.state.selection.main.head);
+/** Returns a command that jumps to the definition of the symbol at `pos`. */
 const jumpToDefinitionPos = (pos) => (view) => requestDefinition(view, pos);
+/** Command: jump to the type definition of the symbol at the cursor. */
 const jumpToTypeDefinition = (view) => requestTypeDefinition(view, view.state.selection.main.head);
+/** Returns a command that jumps to the type definition of the symbol at `pos`. */
 const jumpToTypeDefinitionPos = (pos) => (view) => requestTypeDefinition(view, pos);
+/**
+ * Default keymap for go-to-definition commands.
+ *
+ * - `F12` — jump to definition
+ * - `Mod-F12` — jump to type definition
+ */
 const jumpToDefinitionKeymap = [
     { key: 'F12', run: jumpToDefinition, preventDefault: true },
     { key: 'Mod-F12', run: jumpToTypeDefinition, preventDefault: true },
 ];
 
+/**
+ * Facet for configuring LSP formatting options (tab size, spaces vs tabs, etc.).
+ *
+ * Defaults to `{ tabSize: 4, insertSpaces: true }`. The `tabSize` falls back
+ * to the editor state's `tabSize` if not explicitly set.
+ */
+const formattingOptions = Facet.define({
+    combine(values) {
+        return Object.assign({ tabSize: 4, insertSpaces: true }, ...values);
+    },
+});
+function getFormattingOptions(view) {
+    var _a;
+    const opts = view.state.facet(formattingOptions);
+    return {
+        ...opts,
+        tabSize: (_a = opts.tabSize) !== null && _a !== void 0 ? _a : view.state.tabSize,
+    };
+}
+function applyTextEdits(view, edits) {
+    const changes = edits.map((edit) => ({
+        from: posToOffset(view.state.doc, edit.range.start),
+        to: posToOffset(view.state.doc, edit.range.end),
+        insert: edit.newText,
+    }));
+    view.dispatch(view.state.update({ changes }));
+}
+/** Command: format the entire document using the language server. */
+function formatDocument(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentFormattingProvider)) {
+        return false;
+    }
+    plugin.client
+        .textDocumentFormatting({
+        textDocument: { uri: plugin.documentUri },
+        options: getFormattingOptions(view),
+    })
+        .then((edits) => {
+        if (edits && edits.length > 0) {
+            applyTextEdits(view, edits);
+        }
+    });
+    return true;
+}
+/** Command: format the current selection using the language server. */
+function formatSelection(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentRangeFormattingProvider)) {
+        return false;
+    }
+    const { from, to } = view.state.selection.main;
+    plugin.client
+        .textDocumentRangeFormatting({
+        textDocument: { uri: plugin.documentUri },
+        range: {
+            start: offsetToPos(view.state.doc, from),
+            end: offsetToPos(view.state.doc, to),
+        },
+        options: getFormattingOptions(view),
+    })
+        .then((edits) => {
+        if (edits && edits.length > 0) {
+            applyTextEdits(view, edits);
+        }
+    });
+    return true;
+}
+
+const openRenamePanel = StateEffect.define();
+const closeRenamePanel = StateEffect.define();
+const renamePanelState = StateField.define({
+    create() {
+        return null;
+    },
+    update(value, tr) {
+        for (const effect of tr.effects) {
+            if (effect.is(openRenamePanel))
+                return effect.value;
+            if (effect.is(closeRenamePanel))
+                return null;
+        }
+        return value;
+    },
+    provide: (field) => showPanel.from(field, (value) => value != null ? (view) => createRenamePanel(view, value) : null),
+});
+function applyWorkspaceEdit(view, edit) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return;
+    const changes = [];
+    if (edit.changes) {
+        const edits = edit.changes[plugin.documentUri];
+        if (edits) {
+            for (const e of edits) {
+                changes.push({
+                    from: posToOffset(view.state.doc, e.range.start),
+                    to: posToOffset(view.state.doc, e.range.end),
+                    insert: e.newText,
+                });
+            }
+        }
+    }
+    if (edit.documentChanges) {
+        for (const change of edit.documentChanges) {
+            if ('textDocument' in change) {
+                if (change.textDocument.uri !== plugin.documentUri)
+                    continue;
+                for (const e of change.edits) {
+                    if ('range' in e) {
+                        changes.push({
+                            from: posToOffset(view.state.doc, e.range.start),
+                            to: posToOffset(view.state.doc, e.range.end),
+                            insert: e.newText,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (changes.length > 0) {
+        view.dispatch(view.state.update({ changes }));
+    }
+}
+function createRenamePanel(view, placeholder) {
+    const dom = document.createElement('div');
+    dom.className = 'cm-lsp-rename-panel';
+    const input = document.createElement('input');
+    input.className = 'cm-lsp-rename-input';
+    input.value = placeholder;
+    input.setAttribute('aria-label', 'New name');
+    const submit = () => {
+        const newName = input.value.trim();
+        if (!newName || newName === placeholder) {
+            view.dispatch({ effects: closeRenamePanel.of(null) });
+            view.focus();
+            return;
+        }
+        performRename(view, newName);
+    };
+    input.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+            e.preventDefault();
+            submit();
+        }
+        else if (e.key === 'Escape') {
+            e.preventDefault();
+            view.dispatch({ effects: closeRenamePanel.of(null) });
+            view.focus();
+        }
+    });
+    dom.appendChild(input);
+    return {
+        dom,
+        top: true,
+        mount() {
+            input.select();
+        },
+    };
+}
+async function performRename(view, newName) {
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return;
+    const pos = view.state.selection.main.head;
+    view.dispatch({ effects: closeRenamePanel.of(null) });
+    view.focus();
+    const result = await plugin.client.textDocumentRename({
+        textDocument: { uri: plugin.documentUri },
+        position: offsetToPos(view.state.doc, pos),
+        newName,
+    });
+    if (result) {
+        applyWorkspaceEdit(view, result);
+    }
+}
+/**
+ * Command: open a rename prompt for the symbol at the cursor.
+ *
+ * Uses `textDocument/prepareRename` to pre-fill the current name if supported
+ * by the server. Press Enter to confirm or Escape to cancel.
+ */
+function renameSymbol(view) {
+    var _a;
+    const plugin = view.plugin(languageServerPlugin);
+    if (!plugin)
+        return false;
+    if (!plugin.client.ready ||
+        !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.renameProvider)) {
+        return false;
+    }
+    const pos = view.state.selection.main.head;
+    const capabilities = plugin.client.capabilities;
+    const renameProvider = capabilities.renameProvider;
+    const supportsPrepare = typeof renameProvider === 'object' && renameProvider.prepareProvider;
+    if (supportsPrepare) {
+        plugin.client
+            .textDocumentPrepareRename({
+            textDocument: { uri: plugin.documentUri },
+            position: offsetToPos(view.state.doc, pos),
+        })
+            .then((result) => {
+            if (!result)
+                return;
+            const placeholder = 'placeholder' in result
+                ? result.placeholder
+                : view.state.doc.sliceString(posToOffset(view.state.doc, result.start), posToOffset(view.state.doc, result.end));
+            view.dispatch({
+                effects: openRenamePanel.of(placeholder),
+            });
+        });
+    }
+    else {
+        const word = view.state.wordAt(pos);
+        const placeholder = word
+            ? view.state.doc.sliceString(word.from, word.to)
+            : '';
+        view.dispatch({ effects: openRenamePanel.of(placeholder) });
+    }
+    return true;
+}
+const renameExtension = () => renamePanelState;
+
 const hoverTooltip = () => hoverTooltip$1((view, pos) => {
     var _a;
     const plugin = view.plugin(languageServerPlugin);
@@ -601,7 +1019,8 @@ const autocompletion = () => autocompletion$1({
                 trigKind = CompletionTriggerKind.TriggerCharacter;
                 trigChar = line.text[pos - line.from - 1];
             }
-            if (trigKind === CompletionTriggerKind.Invoked &&
+            if (!explicit &&
+                trigKind === CompletionTriggerKind.Invoked &&
                 !context.matchBefore(/\w+$/)) {
                 return null;
             }
@@ -613,6 +1032,109 @@ const autocompletion = () => autocompletion$1({
     ],
 });
 
+const highlightField = StateField.define({
+    create() {
+        return Decoration.none;
+    },
+    update(decorations, tr) {
+        for (const effect of tr.effects) {
+            if (effect.is(setHighlightsEffect)) {
+                return effect.value;
+            }
+        }
+        if (tr.docChanged) {
+            return Decoration.none;
+        }
+        return decorations;
+    },
+    provide: (field) => EditorView.decorations.from(field),
+});
+const setHighlightsEffect = StateEffect.define();
+const textDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-text',
+});
+const readDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-read',
+});
+const writeDecoration = Decoration.mark({
+    class: 'cm-lsp-highlight-write',
+});
+function decorationForKind(kind) {
+    switch (kind) {
+        case DocumentHighlightKind.Read:
+            return readDecoration;
+        case DocumentHighlightKind.Write:
+            return writeDecoration;
+        default:
+            return textDecoration;
+    }
+}
+const highlightPlugin = ViewPlugin.fromClass(class {
+    constructor() {
+        this.pending = -1;
+    }
+    update(update) {
+        if (!update.selectionSet && !update.docChanged) {
+            return;
+        }
+        if (update.docChanged) {
+            return;
+        }
+        clearTimeout(this.pending);
+        this.pending = setTimeout(() => this.requestHighlights(update.view), 100);
+    }
+    async requestHighlights(view) {
+        var _a;
+        const plugin = view.plugin(languageServerPlugin);
+        if (!plugin)
+            return;
+        const { state } = view;
+        const pos = state.selection.main.head;
+        if (!plugin.client.ready ||
+            !((_a = plugin.client.capabilities) === null || _a === void 0 ? void 0 : _a.documentHighlightProvider)) {
+            view.dispatch({ effects: setHighlightsEffect.of(Decoration.none) });
+            return;
+        }
+        const result = await plugin.client.textDocumentDocumentHighlight({
+            textDocument: { uri: plugin.documentUri },
+            position: offsetToPos(state.doc, pos),
+        });
+        if (view.state.selection.main.head !== pos) {
+            return;
+        }
+        if (!result || result.length === 0) {
+            view.dispatch({ effects: setHighlightsEffect.of(Decoration.none) });
+            return;
+        }
+        const decorations = result
+            .map((highlight) => {
+            const from = posToOffset(view.state.doc, highlight.range.start);
+            const to = posToOffset(view.state.doc, highlight.range.end);
+            if (from == null || to == null)
+                return null;
+            return decorationForKind(highlight.kind).range(from, to);
+        })
+            .filter((d) => d != null)
+            .sort((a, b) => a.from - b.from);
+        view.dispatch({
+            effects: setHighlightsEffect.of(Decoration.set(decorations)),
+        });
+    }
+    destroy() {
+        clearTimeout(this.pending);
+    }
+});
+/**
+ * Extension that highlights all occurrences of the symbol under the cursor.
+ *
+ * Applies CSS classes `cm-lsp-highlight-text`, `cm-lsp-highlight-read`, and
+ * `cm-lsp-highlight-write` based on the highlight kind returned by the server.
+ */
+const documentHighlight = () => [
+    highlightField,
+    highlightPlugin,
+];
+
 const mouseHandler = () => EditorView.domEventHandlers({
     mousedown: (event, view) => {
         if (!event.ctrlKey && !event.metaKey)
@@ -629,6 +1151,12 @@ const mouseHandler = () => EditorView.domEventHandlers({
     },
 });
 
+/**
+ * Creates a set of CodeMirror extensions that connect to a language server over WebSocket.
+ *
+ * Includes completion, hover, diagnostics, go-to-definition, document highlight,
+ * and rename support. This is the main entry point for most use cases.
+ */
 function languageServer(options) {
     const serverUri = options.serverUri;
     const { serverUri: _, ...optionsWithoutServerUri } = options;
@@ -637,6 +1165,11 @@ function languageServer(options) {
         transport: new WebSocketTransport(serverUri),
     });
 }
+/**
+ * Like {@link languageServer}, but accepts a custom {@link Transport} instead of a WebSocket URI.
+ *
+ * Use this when communicating with the language server over a non-WebSocket channel.
+ */
 function languageServerWithTransport(options) {
     return [
         languageServerPlugin.of({
@@ -652,9 +1185,11 @@ function languageServerWithTransport(options) {
         }),
         hoverTooltip(),
         autocompletion(),
+        documentHighlight(),
+        renameExtension(),
         keymap.of([...jumpToDefinitionKeymap]),
         mouseHandler(),
     ];
 }
 
-export { LanguageServerClient, SynchronizationMethod, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport };
+export { LanguageServerClient, SynchronizationMethod, WebSocketTransport, formatDocument, formatSelection, formattingOptions, jumpToDefinition, jumpToDefinitionKeymap, jumpToDefinitionPos, languageServer, languageServerPlugin, languageServerWithTransport, renameSymbol };