@nvl/sveltex-language-server 0.2.0

package/dist/core/regions.d.ts

@@ -0,0 +1,56 @@
+import type { SveltexConfigSnapshot } from './config.js';
+/**
+ * The kind of a {@link Region}.
+ *
+ * - `markdown`: Plain Markdown / HTML. Delegated to the Svelte language server
+ *   (which understands the HTML subset) and additionally analyzed natively for
+ *   Markdown-specific features (folding, symbols, selection ranges).
+ * - `svelte`: Svelte markup that is _not_ a mustache tag — `<script>`,
+ *   `<style>`, `<svelte:*>` elements, logic blocks (`{#if}`/`{/if}`/...) and
+ *   special tags (`{@const}`, `{@debug}`, ...). Delegated verbatim.
+ * - `mustacheTag`: A Svelte mustache tag, e.g. `{name}`. Delegated verbatim.
+ * - `code`: A fenced code block or inline code span. _Not_ delegated.
+ * - `math`: Inline or display math (`$...$`, `$$...$$`, `\(...\)`, `\[...\]`).
+ *   _Not_ delegated.
+ * - `verbatim`: A SvelTeX verbatim environment (`<tex>`, `<verbatim>`, ...).
+ *   _Not_ delegated.
+ * - `frontmatter`: A YAML / TOML / JSON frontmatter block. _Not_ delegated.
+ */
+export type RegionKind = 'markdown' | 'svelte' | 'mustacheTag' | 'code' | 'math' | 'verbatim' | 'frontmatter';
+/**
+ * A contiguous slice of a `.sveltex` document, classified by {@link RegionKind}.
+ *
+ * `Region`s returned by {@link computeRegions} tile the entire document
+ * gap-free: `regions[i].sourceEnd === regions[i + 1].sourceStart`, the first
+ * region starts at offset `0`, and the last ends at `document.length`.
+ */
+export interface Region {
+    /** What kind of content this region holds. */
+    kind: RegionKind;
+    /** Offset of the first character of the region (inclusive). */
+    sourceStart: number;
+    /** Offset one past the last character of the region (exclusive). */
+    sourceEnd: number;
+}
+/**
+ * Returns whether a region of the given kind should be delegated to the
+ * embedded Svelte language server.
+ */
+export declare function isDelegated(kind: RegionKind): boolean;
+/**
+ * Parses a `.sveltex` document and returns a gap-free, sorted list of
+ * {@link Region}s.
+ *
+ * @param document - The full text of the `.sveltex` file.
+ * @param config - A snapshot of the resolved `sveltex.config.*` (verbatim tags,
+ * math delimiters, directive settings).
+ * @returns The document's regions, tiling `[0, document.length)` with no gaps
+ * and no overlaps.
+ *
+ * @remarks
+ * The heavy lifting is done by SvelTeX's own exported detectors
+ * (`parseToMdast`, `getMdastES`, `getSvelteES`, `getMathInSpecialDelimsES`,
+ * `getColonES`) plus `outermostRanges` to discard nested matches. Anything not
+ * covered by a detected snippet is emitted as a `markdown` region.
+ */
+export declare function computeRegions(document: string, config: SveltexConfigSnapshot): Region[];

package/dist/core/regions.js

@@ -0,0 +1,221 @@
+// File description: Splits a `.sveltex` document into a flat, gap-free array of
+// `Region`s by reusing SvelTeX's own region-detection building blocks.
+//
+// SvelTeX's preprocessor produces no usable source map for markup (see the
+// package README), so the LSP must reconstruct the region structure itself.
+// Fortunately `@nvl/sveltex` exports the precise, offset-bearing detectors it
+// uses internally. We call those and classify each detected snippet as either
+// "delegated" (handed to the embedded Svelte language server) or "non-delegated"
+// (verbatim / code / math / frontmatter — blanked out before delegation).
+//
+// TODO: upstream a public `getRegions()` into `@nvl/sveltex` so that this file
+// can stop importing from the `dist/` deep path below.
+import { getColonES, getMathInSpecialDelimsES, getMdastES, getSvelteES, outermostRanges, parseToMdast, } from '@nvl/sveltex/dist/utils/escape.js';
+/**
+ * `RegionKind`s whose contents are forwarded verbatim to the embedded Svelte
+ * language server. Everything else is blanked out in the virtual document.
+ */
+const DELEGATED_KINDS = new Set([
+    'markdown',
+    'svelte',
+    'mustacheTag',
+]);
+/**
+ * Returns whether a region of the given kind should be delegated to the
+ * embedded Svelte language server.
+ */
+export function isDelegated(kind) {
+    return DELEGATED_KINDS.has(kind);
+}
+/**
+ * Maps a SvelTeX snippet `type` to the LSP's {@link RegionKind}.
+ *
+ * SvelTeX snippet types are `code | math | svelte | mustacheTag | verbatim |
+ * frontmatter`, which line up one-to-one with our region kinds (none of them is
+ * `markdown` — plain Markdown is whatever is left over).
+ */
+function snippetTypeToRegionKind(type) {
+    switch (type) {
+        case 'code':
+        case 'math':
+        case 'svelte':
+        case 'mustacheTag':
+        case 'verbatim':
+        case 'frontmatter':
+            return type;
+        default:
+            // Defensive: an unknown snippet type is treated as opaque verbatim
+            // so that it is never mistakenly delegated.
+            return 'verbatim';
+    }
+}
+/**
+ * Detects SvelTeX verbatim environments (`<tex>...</tex>`, `<verbatim/>`, ...).
+ *
+ * SvelTeX's `getVerbatimES` is _not_ part of the package's public surface, so
+ * we re-derive the (simple) detection here: a verbatim environment is just an
+ * HTML-like element whose tag name is one of the configured verbatim tags. This
+ * intentionally mirrors the regexes in `@nvl/sveltex`'s `escape.ts`.
+ *
+ * TODO: replace with `getVerbatimES` once `@nvl/sveltex` exports it.
+ */
+function detectVerbatimRanges(document, verbatimTags) {
+    const ranges = [];
+    if (verbatimTags.length === 0)
+        return ranges;
+    const alternation = verbatimTags
+        .map((t) => t.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'))
+        .join('|');
+    // Matches `<tag ...>...</tag>` (with lazy inner content) or `<tag ... />`.
+    // `s` flag: `.` spans newlines. `u` flag is required by the repo's lint.
+    const re = new RegExp(`<(${alternation})(?:\\s[^>]*?)?(?:/>|>.*?</\\s*\\1\\s*>)`, 'gisu');
+    for (const match of document.matchAll(re)) {
+        const start = match.index;
+        ranges.push({
+            kind: 'verbatim',
+            start,
+            end: start + match[0].length,
+        });
+    }
+    return ranges;
+}
+/**
+ * Returns a copy of `document` with every character inside one of `ranges`
+ * replaced by a space; newline characters are kept, so offsets _and_ line
+ * numbers are preserved.
+ *
+ * It is used to hide already-classified snippets from the verbatim-tag scan:
+ * a `<tex>` written inside an inline-code span (`` `<tex>` ``), a string in a
+ * `<script>`, etc. must not be mistaken for the opening of a verbatim
+ * environment — otherwise its match runs greedily to the next, unrelated
+ * `</tex>` and swallows the real block in between.
+ */
+function maskRanges(document, ranges) {
+    if (ranges.length === 0)
+        return document;
+    const chars = document.split('');
+    for (const range of ranges) {
+        const end = Math.min(range.end, chars.length);
+        for (let i = Math.max(0, range.start); i < end; i += 1) {
+            const ch = chars[i];
+            if (ch !== '\n' && ch !== '\r')
+                chars[i] = ' ';
+        }
+    }
+    return chars.join('');
+}
+/**
+ * Parses a `.sveltex` document and returns a gap-free, sorted list of
+ * {@link Region}s.
+ *
+ * @param document - The full text of the `.sveltex` file.
+ * @param config - A snapshot of the resolved `sveltex.config.*` (verbatim tags,
+ * math delimiters, directive settings).
+ * @returns The document's regions, tiling `[0, document.length)` with no gaps
+ * and no overlaps.
+ *
+ * @remarks
+ * The heavy lifting is done by SvelTeX's own exported detectors
+ * (`parseToMdast`, `getMdastES`, `getSvelteES`, `getMathInSpecialDelimsES`,
+ * `getColonES`) plus `outermostRanges` to discard nested matches. Anything not
+ * covered by a detected snippet is emitted as a `markdown` region.
+ */
+export function computeRegions(document, config) {
+    const tagged = [];
+    try {
+        const verbatimTags = config.verbatimTags;
+        const mdastTags = [...verbatimTags, 'script', 'style'];
+        const ast = parseToMdast(document, mdastTags, config.mathDelims, config.directives);
+        const lines = document.split(/\r\n?|\n/u);
+        const snippets = [
+            ...getMdastES({
+                ast,
+                document,
+                lines,
+                texSettings: config.mathDelims,
+                directiveSettings: config.directives,
+            }),
+            ...getSvelteES(document),
+            ...getMathInSpecialDelimsES(document, config.mathDelims),
+        ];
+        // `getColonES` reports the individual `:` characters inside special
+        // Svelte elements (`<svelte:head>` etc.). Those colons live inside
+        // `svelte`/`markdown` regions already, so they need no separate region;
+        // we only consult `getColonES` to stay forward-compatible and ignore
+        // its output here.
+        void getColonES;
+        for (const snippet of outermostRanges([...snippets], 'original.loc')) {
+            tagged.push({
+                kind: snippetTypeToRegionKind(snippet.type),
+                start: snippet.original.loc.start,
+                end: snippet.original.loc.end,
+            });
+        }
+        // Scan for verbatim environments over a copy of the document with
+        // every snippet found above blanked out. A bare regex scan of the raw
+        // document would anchor on a `<tex>` that is really inside an
+        // inline-code span and pair it with a *later*, unrelated `</tex>` —
+        // swallowing the genuine verbatim block in between.
+        tagged.push(...detectVerbatimRanges(maskRanges(document, tagged), verbatimTags));
+    }
+    catch {
+        // If SvelTeX's parser throws (malformed input mid-edit is common), fall
+        // back to treating the whole document as delegated Markdown. The Svelte
+        // language server is itself resilient to partial input.
+        return [
+            { kind: 'markdown', sourceStart: 0, sourceEnd: document.length },
+        ];
+    }
+    return fillGaps(tagged, document.length);
+}
+/**
+ * Sorts tagged ranges, drops overlaps, and fills the holes between them with
+ * `markdown` regions so that the result tiles `[0, length)` exactly.
+ */
+function fillGaps(tagged, length) {
+    // `outermostRanges` already removed nesting among the mdast/svelte snippets,
+    // but verbatim ranges were appended afterwards and could overlap a snippet
+    // (e.g. a verbatim tag that also looks like an HTML element). Re-run the
+    // outermost filter over the combined set, sorted by start offset.
+    const sorted = [...tagged].sort((a, b) => a.start !== b.start ? a.start - b.start : b.end - a.end);
+    const regions = [];
+    let cursor = 0;
+    for (const range of sorted) {
+        // Skip ranges that overlap something we already emitted.
+        if (range.start < cursor)
+            continue;
+        if (range.start >= length)
+            break;
+        const end = Math.min(range.end, length);
+        if (end <= range.start)
+            continue;
+        // Fill the gap before this range with plain Markdown.
+        if (range.start > cursor) {
+            regions.push({
+                kind: 'markdown',
+                sourceStart: cursor,
+                sourceEnd: range.start,
+            });
+        }
+        regions.push({
+            kind: range.kind,
+            sourceStart: range.start,
+            sourceEnd: end,
+        });
+        cursor = end;
+    }
+    // Trailing Markdown.
+    if (cursor < length) {
+        regions.push({
+            kind: 'markdown',
+            sourceStart: cursor,
+            sourceEnd: length,
+        });
+    }
+    // An empty document still yields one (empty) Markdown region so that
+    // downstream consumers never have to special-case `regions.length === 0`.
+    if (regions.length === 0) {
+        regions.push({ kind: 'markdown', sourceStart: 0, sourceEnd: length });
+    }
+    return regions;
+}

package/dist/core/remap.d.ts

@@ -0,0 +1,84 @@
+import type { CodeAction, Command, CompletionItem, CompletionList, Definition, DefinitionLink, DocumentHighlight, DocumentLink, Hover, Location, Range, SignatureHelp, WorkspaceEdit } from 'vscode-languageserver-protocol';
+import type { SourceMap } from './mapper.js';
+/**
+ * Bundles the two URIs and the source map for one open `.sveltex` file, so the
+ * remapping helpers have everything they need in a single argument.
+ */
+export interface RemapContext {
+    /** The real `.sveltex` document URI as seen by the editor. */
+    sourceUri: string;
+    /** The synthetic `<source>.svelte` URI handed to the embedded server. */
+    virtualUri: string;
+    /** Bidirectional mapper between the two documents. */
+    sourceMap: SourceMap;
+}
+/**
+ * Derives the virtual `.svelte` URI for a given `.sveltex` source URI.
+ *
+ * Appending `.svelte` (rather than replacing the extension) keeps the original
+ * name recoverable and makes the embedded TypeScript service treat the file as
+ * Svelte.
+ */
+export declare function toVirtualUri(sourceUri: string): string;
+/** Inverse of {@link toVirtualUri}. */
+export declare function toSourceUri(virtualUri: string): string;
+/**
+ * Remaps the result of a definition / declaration / type-definition /
+ * implementation request.
+ */
+export declare function remapDefinition(result: Definition | DefinitionLink[] | null | undefined, ctx: RemapContext): Definition | DefinitionLink[] | null;
+/**
+ * Remaps the result of a find-references request.
+ */
+export declare function remapReferences(result: Location[] | null | undefined, ctx: RemapContext): Location[] | null;
+/**
+ * Remaps the result of a document-highlight request. Highlights always refer to
+ * the requested document, so any highlight that fails to map is dropped.
+ */
+export declare function remapHighlights(result: DocumentHighlight[] | null | undefined, ctx: RemapContext): DocumentHighlight[] | null;
+/**
+ * Remaps a hover result. The optional `range` is mapped; if it fails to map the
+ * hover is dropped entirely (its contents describe code that, from the user's
+ * point of view, is not at the hovered spot).
+ */
+export declare function remapHover(result: Hover | null | undefined, ctx: RemapContext): Hover | null;
+/**
+ * Remaps a completion result (either a bare item array or a `CompletionList`).
+ */
+export declare function remapCompletion(result: CompletionItem[] | CompletionList | null | undefined, ctx: RemapContext): CompletionItem[] | CompletionList | null;
+/**
+ * Remaps a `WorkspaceEdit` (the result of a rename). Only the `changes` keyed
+ * by the virtual URI are rewritten; edits to other files pass through.
+ *
+ * @remarks
+ * `documentChanges` (the versioned form) is intentionally _not_ remapped in
+ * v1: `svelte-language-server`'s rename returns the `changes` form, and
+ * versioned edits would also require tracking the source document's version.
+ *
+ * TODO: support `documentChanges` once incremental virtual updates land.
+ */
+export declare function remapWorkspaceEdit(result: WorkspaceEdit | null | undefined, ctx: RemapContext): WorkspaceEdit | null;
+/**
+ * Remaps a code-action result. Each action may carry an inline `WorkspaceEdit`
+ * and a list of `diagnostics`; both are rewritten. Bare `Command`s have no
+ * positions and pass through unchanged.
+ */
+export declare function remapCodeActions(result: (Command | CodeAction)[] | null | undefined, ctx: RemapContext): (Command | CodeAction)[] | null;
+/**
+ * Remaps a signature-help result. `SignatureHelp` carries no document ranges,
+ * so it is returned unchanged; the function exists to keep the proxy call sites
+ * uniform and to provide an obvious hook should a future LSP version add
+ * positional data.
+ */
+export declare function remapSignatureHelp(result: SignatureHelp | null | undefined): SignatureHelp | null;
+/**
+ * Remaps document links: each link's `range` is in generated coordinates.
+ */
+export declare function remapDocumentLinks(result: DocumentLink[] | null | undefined, ctx: RemapContext): DocumentLink[] | null;
+/**
+ * Maps a `Range` from source to generated coordinates, for request payloads
+ * (e.g. the `range` of a code-action request).
+ *
+ * @returns The generated range, or `undefined` if it is not fully mapped.
+ */
+export declare function sourceRangeToGenerated(range: Range, ctx: RemapContext): Range | undefined;

package/dist/core/remap.js

@@ -0,0 +1,272 @@
+// File description: Pure helpers that rewrite the position-bearing parts of LSP
+// payloads between source (`.sveltex`) and generated (`.svelte`) coordinates.
+//
+// The host server holds, per open file, exactly one virtual `.svelte` document
+// (see `virtual-svelte.ts`). Translating a request therefore means: rewrite the
+// source URI to the virtual URI and map the request position source -> generated;
+// translating a response means the reverse, plus dropping anything that maps
+// into a non-delegated (unmapped) region.
+/**
+ * Derives the virtual `.svelte` URI for a given `.sveltex` source URI.
+ *
+ * Appending `.svelte` (rather than replacing the extension) keeps the original
+ * name recoverable and makes the embedded TypeScript service treat the file as
+ * Svelte.
+ */
+export function toVirtualUri(sourceUri) {
+    return `${sourceUri}.svelte`;
+}
+/** Inverse of {@link toVirtualUri}. */
+export function toSourceUri(virtualUri) {
+    return virtualUri.endsWith('.svelte')
+        ? virtualUri.slice(0, -'.svelte'.length)
+        : virtualUri;
+}
+/**
+ * Rewrites a `Location` from generated to source coordinates.
+ *
+ * @returns The remapped location, or `undefined` if it does not belong to this
+ * document's virtual file or maps into an unmapped region.
+ */
+function remapLocation(location, ctx) {
+    if (location.uri !== ctx.virtualUri) {
+        // A location in some other file (e.g. a `node_modules` `.d.ts`) needs
+        // no mapping — pass it through untouched.
+        return location;
+    }
+    const range = ctx.sourceMap.generatedRangeToSource(location.range);
+    if (!range)
+        return undefined;
+    return { uri: ctx.sourceUri, range };
+}
+/**
+ * Rewrites a `LocationLink` from generated to source coordinates.
+ */
+function remapLocationLink(link, ctx) {
+    if (link.targetUri !== ctx.virtualUri)
+        return link;
+    const targetRange = ctx.sourceMap.generatedRangeToSource(link.targetRange);
+    const targetSelectionRange = ctx.sourceMap.generatedRangeToSource(link.targetSelectionRange);
+    if (!targetRange || !targetSelectionRange)
+        return undefined;
+    const originSelectionRange = link.originSelectionRange
+        ? ctx.sourceMap.generatedRangeToSource(link.originSelectionRange)
+        : undefined;
+    return {
+        ...link,
+        targetUri: ctx.sourceUri,
+        targetRange,
+        targetSelectionRange,
+        ...(originSelectionRange ? { originSelectionRange } : {}),
+    };
+}
+/**
+ * Remaps the result of a definition / declaration / type-definition /
+ * implementation request.
+ */
+export function remapDefinition(result, ctx) {
+    if (!result)
+        return null;
+    if (Array.isArray(result)) {
+        // Either `Location[]` or `LocationLink[]`; both are handled per-item.
+        const out = result
+            .map((item) => 'targetUri' in item
+            ? remapLocationLink(item, ctx)
+            : remapLocation(item, ctx))
+            .filter((item) => Boolean(item));
+        return out;
+    }
+    return remapLocation(result, ctx) ?? null;
+}
+/**
+ * Remaps the result of a find-references request.
+ */
+export function remapReferences(result, ctx) {
+    if (!result)
+        return null;
+    return result
+        .map((loc) => remapLocation(loc, ctx))
+        .filter((loc) => Boolean(loc));
+}
+/**
+ * Remaps the result of a document-highlight request. Highlights always refer to
+ * the requested document, so any highlight that fails to map is dropped.
+ */
+export function remapHighlights(result, ctx) {
+    if (!result)
+        return null;
+    return result
+        .map((highlight) => {
+        const range = ctx.sourceMap.generatedRangeToSource(highlight.range);
+        if (!range)
+            return undefined;
+        return { ...highlight, range };
+    })
+        .filter((h) => Boolean(h));
+}
+/**
+ * Remaps a hover result. The optional `range` is mapped; if it fails to map the
+ * hover is dropped entirely (its contents describe code that, from the user's
+ * point of view, is not at the hovered spot).
+ */
+export function remapHover(result, ctx) {
+    if (!result)
+        return null;
+    if (!result.range)
+        return result;
+    const range = ctx.sourceMap.generatedRangeToSource(result.range);
+    if (!range)
+        return null;
+    return { ...result, range };
+}
+/**
+ * Remaps an array of `TextEdit`s, dropping edits whose range does not map.
+ */
+function remapTextEdits(edits, ctx) {
+    return edits
+        .map((edit) => {
+        const range = ctx.sourceMap.generatedRangeToSource(edit.range);
+        if (!range)
+            return undefined;
+        return { ...edit, range };
+    })
+        .filter((edit) => Boolean(edit));
+}
+/**
+ * Remaps a single completion item: its `textEdit` and `additionalTextEdits`
+ * carry ranges in generated coordinates.
+ *
+ * @returns The remapped item, or `undefined` if its primary `textEdit` range
+ * cannot be mapped (applying it would corrupt the source document).
+ */
+function remapCompletionItem(item, ctx) {
+    const next = { ...item };
+    if (item.textEdit) {
+        if ('range' in item.textEdit) {
+            const range = ctx.sourceMap.generatedRangeToSource(item.textEdit.range);
+            if (!range)
+                return undefined;
+            next.textEdit = { ...item.textEdit, range };
+        }
+        else {
+            // `InsertReplaceEdit`: map both ranges.
+            const insert = ctx.sourceMap.generatedRangeToSource(item.textEdit.insert);
+            const replace = ctx.sourceMap.generatedRangeToSource(item.textEdit.replace);
+            if (!insert || !replace)
+                return undefined;
+            next.textEdit = { ...item.textEdit, insert, replace };
+        }
+    }
+    if (item.additionalTextEdits) {
+        next.additionalTextEdits = remapTextEdits(item.additionalTextEdits, ctx);
+    }
+    return next;
+}
+/**
+ * Remaps a completion result (either a bare item array or a `CompletionList`).
+ */
+export function remapCompletion(result, ctx) {
+    if (!result)
+        return null;
+    const items = Array.isArray(result) ? result : result.items;
+    const remapped = items
+        .map((item) => remapCompletionItem(item, ctx))
+        .filter((item) => Boolean(item));
+    if (Array.isArray(result))
+        return remapped;
+    return { ...result, items: remapped };
+}
+/**
+ * Remaps a `WorkspaceEdit` (the result of a rename). Only the `changes` keyed
+ * by the virtual URI are rewritten; edits to other files pass through.
+ *
+ * @remarks
+ * `documentChanges` (the versioned form) is intentionally _not_ remapped in
+ * v1: `svelte-language-server`'s rename returns the `changes` form, and
+ * versioned edits would also require tracking the source document's version.
+ *
+ * TODO: support `documentChanges` once incremental virtual updates land.
+ */
+export function remapWorkspaceEdit(result, ctx) {
+    if (!result)
+        return null;
+    if (!result.changes)
+        return result;
+    const changes = {};
+    for (const [uri, edits] of Object.entries(result.changes)) {
+        if (uri === ctx.virtualUri) {
+            changes[ctx.sourceUri] = remapTextEdits(edits, ctx);
+        }
+        else {
+            changes[uri] = edits;
+        }
+    }
+    return { ...result, changes };
+}
+/**
+ * Remaps a code-action result. Each action may carry an inline `WorkspaceEdit`
+ * and a list of `diagnostics`; both are rewritten. Bare `Command`s have no
+ * positions and pass through unchanged.
+ */
+export function remapCodeActions(result, ctx) {
+    if (!result)
+        return null;
+    return result.map((entry) => {
+        // `CodeAction` carries `edit` / `diagnostics`; a bare `Command` has
+        // neither. Probing for those keys narrows `entry` to `CodeAction`
+        // without a cast (a `Command` is returned unchanged — it has no
+        // positions).
+        if (!('edit' in entry) && !('diagnostics' in entry)) {
+            return entry;
+        }
+        const action = entry;
+        const next = { ...action };
+        if (action.edit) {
+            next.edit = remapWorkspaceEdit(action.edit, ctx) ?? action.edit;
+        }
+        if (action.diagnostics) {
+            next.diagnostics = action.diagnostics
+                .map((diag) => {
+                const range = ctx.sourceMap.generatedRangeToSource(diag.range);
+                if (!range)
+                    return undefined;
+                return { ...diag, range };
+            })
+                .filter((d) => Boolean(d));
+        }
+        return next;
+    });
+}
+/**
+ * Remaps a signature-help result. `SignatureHelp` carries no document ranges,
+ * so it is returned unchanged; the function exists to keep the proxy call sites
+ * uniform and to provide an obvious hook should a future LSP version add
+ * positional data.
+ */
+export function remapSignatureHelp(result) {
+    return result ?? null;
+}
+/**
+ * Remaps document links: each link's `range` is in generated coordinates.
+ */
+export function remapDocumentLinks(result, ctx) {
+    if (!result)
+        return null;
+    return result
+        .map((link) => {
+        const range = ctx.sourceMap.generatedRangeToSource(link.range);
+        if (!range)
+            return undefined;
+        return { ...link, range };
+    })
+        .filter((link) => Boolean(link));
+}
+/**
+ * Maps a `Range` from source to generated coordinates, for request payloads
+ * (e.g. the `range` of a code-action request).
+ *
+ * @returns The generated range, or `undefined` if it is not fully mapped.
+ */
+export function sourceRangeToGenerated(range, ctx) {
+    return ctx.sourceMap.sourceRangeToGenerated(range);
+}