@adecore/editor-react 0.22.1 → 0.23.1

package/dist/diff-expansion.js

@@ -0,0 +1,41 @@
+import { diffRows } from '@adecore/merge';
+export const DEFAULT_UNFOLD_LIMITS = { rows: 20000, characters: 2000000, lineLength: 10000 };
+export function fitsDiff(document, unfolded, limits, maxRows = limits.rows) {
+    let rows = 0;
+    let characters = 0;
+    for (const row of diffRows(document, 'unified', unfolded)) {
+        if (row.kind === 'gap') {
+            continue;
+        }
+        const text = row.new === undefined ? document.sides.old[row.old.index] : document.sides.new[row.new.index];
+        characters += text.length + (rows > 0 ? 1 : 0);
+        if (++rows > maxRows || characters > limits.characters || text.length > limits.lineLength) {
+            return false;
+        }
+    }
+    return true;
+}
+export function expandDiff(document, unfolded, id, limits) {
+    const rows = diffRows(document, 'unified', unfolded);
+    const gap = rows.find((row) => row.kind === 'gap' && row.id === id);
+    if (gap?.kind !== 'gap' || !gap.unfoldable) {
+        return unfolded;
+    }
+    const visible = rows.filter((row) => row.kind === 'line').length;
+    const maxRows = Math.min(limits.rows, visible + 500);
+    const previous = unfolded.get(id) ?? 0;
+    let low = 0;
+    let high = Math.min(500, gap.oldCount);
+    // Between-hunk gaps reveal from both ends; search the per-end count within the shared row budget.
+    while (low < high) {
+        const count = Math.ceil((low + high) / 2);
+        const candidate = new Map(unfolded).set(id, previous + count);
+        if (fitsDiff(document, candidate, limits, maxRows)) {
+            low = count;
+        }
+        else {
+            high = count - 1;
+        }
+    }
+    return low === 0 ? unfolded : new Map(unfolded).set(id, previous + low);
+}

package/dist/diff-overlays.d.ts

@@ -0,0 +1,15 @@
+import type { Editor, EditorEngine } from '@adecore/editor';
+import type { DiffDisplay } from '@adecore/merge';
+import { RowHost, LineActionHost } from './row-host.ts';
+export interface MountedDiff {
+    engine: EditorEngine;
+    editor: Editor;
+    rows: RowHost;
+    actions: LineActionHost;
+}
+export declare function DiffOverlays({ mounted, display, unfold, blocked }: {
+    mounted: MountedDiff;
+    display: DiffDisplay;
+    unfold(id: number): void;
+    blocked?: ReadonlySet<number>;
+}): import("react").JSX.Element;

package/dist/diff-overlays.js

@@ -0,0 +1,28 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useSyncExternalStore } from 'react';
+import { createPortal } from 'react-dom';
+import { useTranslation } from 'react-i18next';
+import { Button } from '@adecore/ui';
+import { formatNumber } from '@adecore/ui/format';
+import { RowHost, LineActionHost } from './row-host.js';
+export function DiffOverlays({ mounted, display, unfold, blocked }) {
+    const { t } = useTranslation('editor');
+    useSyncExternalStore(mounted.rows.subscribe, mounted.rows.getVersion, mounted.rows.getVersion);
+    useSyncExternalStore(mounted.actions.subscribe, mounted.actions.getVersion, mounted.actions.getVersion);
+    return (_jsxs(_Fragment, { children: [display.gaps.map(({ row }) => {
+                const container = mounted.rows.container(`gap-${row.id}`);
+                if (container === undefined) {
+                    return null;
+                }
+                const text = t('diff.hidden', { count: formatNumber(Math.max(row.oldCount, row.newCount)) });
+                return createPortal(_jsx("div", { className: "adecore-editor-diff-gap", children: row.unfoldable ? (_jsx(Button, { size: "xs", disabled: blocked?.has(row.id), title: blocked?.has(row.id) ? t('diff.contextLimit') : undefined, onClick: () => unfold(row.id), children: text })) : (_jsx("span", { children: text })) }), container, `gap-${row.id}`);
+            }), display.rows.map((row, index) => {
+                if (row.noNewline === undefined) {
+                    return null;
+                }
+                const container = mounted.actions.container(`no-newline-${index}`);
+                return container === undefined
+                    ? null
+                    : createPortal(_jsx("span", { className: "adecore-editor-diff-no-newline", children: t('diff.noNewline') }), container, `no-newline-${index}`);
+            })] }));
+}

package/dist/diff-syntax.d.ts

@@ -0,0 +1,16 @@
+import type { LineToken } from '@adecore/editor';
+import type { DiffSyntaxDocument } from '@adecore/editor/shiki-worker';
+import type { DiffDocument } from '@adecore/merge';
+export type DiffSourceSide = 'old' | 'new';
+export interface DiffSourceTokens {
+    get(side: DiffSourceSide, index: number): readonly LineToken[] | null | undefined;
+    subscribe(listener: () => void): () => void;
+}
+export interface DiffSyntaxSources {
+    readonly documents: Readonly<Record<DiffSourceSide, DiffSyntaxDocument>>;
+    locate(side: DiffSourceSide, index: number): {
+        readonly block: number;
+        readonly line: number;
+    } | undefined;
+}
+export declare function diffSyntaxDocument(document: DiffDocument, language: string, theme: string): DiffSyntaxSources;

package/dist/diff-syntax.js

@@ -0,0 +1,49 @@
+function canTokenize(source) {
+    if (source.length > 20000) {
+        return false;
+    }
+    let characters = Math.max(0, source.length - 1);
+    for (const line of source) {
+        characters += line.length;
+        if (line.length > 10000 || characters > 2000000) {
+            return false;
+        }
+    }
+    return true;
+}
+export function diffSyntaxDocument(document, language, theme) {
+    const locations = { old: [], new: [] };
+    const build = (side) => {
+        const source = document.sides[side];
+        // Skipping a long hidden line loses grammar state; keep the entire side plain instead.
+        if (!canTokenize(source)) {
+            return { language, theme, blocks: [], resets: [] };
+        }
+        const blocks = [];
+        const resets = [];
+        const ranges = document.snapshots
+            ? [{ from: 0, to: source.length }]
+            : document.offsets.map((offset, index) => ({ from: offset[side], to: document.offsets[index + 1]?.[side] ?? source.length }));
+        for (const range of ranges) {
+            if (!document.snapshots && range.from < range.to) {
+                resets.push(blocks.length);
+            }
+            for (let from = range.from; from < range.to; from += 200) {
+                const to = Math.min(from + 200, range.to);
+                const block = blocks.length;
+                blocks.push(source.slice(from, to).join('\n'));
+                for (let index = from; index < to; index++) {
+                    locations[side][index] = { block, line: index - from };
+                }
+            }
+        }
+        return { language, theme, blocks, resets };
+    };
+    const documents = { old: build('old'), new: build('new') };
+    return {
+        documents,
+        locate(side, index) {
+            return Number.isInteger(index) && index >= 0 ? locations[side][index] : undefined;
+        }
+    };
+}

package/dist/diff-wordmarks.d.ts

@@ -0,0 +1,5 @@
+import { type DiffDocument } from '@adecore/merge';
+export declare function wordMarks(document: DiffDocument): {
+    old: Map<number, readonly (readonly [number, number])[]>;
+    new: Map<number, readonly (readonly [number, number])[]>;
+};

package/dist/diff-wordmarks.js

@@ -0,0 +1,26 @@
+import { diffRows, wordChanges } from '@adecore/merge';
+export function wordMarks(document) {
+    const marks = { old: new Map(), new: new Map() };
+    let pairs = 0;
+    let characters = 0;
+    for (const row of diffRows(document, 'split')) {
+        if (row.kind !== 'line' || row.change !== 'pair' || document.hunks[row.hunk].coarse) {
+            continue;
+        }
+        const old = document.sides.old[row.old.index];
+        const fresh = document.sides.new[row.new.index];
+        characters += old.length + fresh.length;
+        // Per-pair limits alone still allow thousands of expensive word diffs during one mount.
+        if (++pairs > 1000 || characters > 100000) {
+            break;
+        }
+        const words = wordChanges(old, fresh);
+        if (words === null) {
+            continue;
+        }
+        const ranges = (text, ranges) => ranges.filter((range) => !document.ignoreWhitespace || /\S/.test(text.slice(range.from, range.to))).map((range) => [range.from, range.to]);
+        marks.old.set(row.old.index, ranges(old, words.old));
+        marks.new.set(row.new.index, ranges(fresh, words.new));
+    }
+    return marks;
+}

package/dist/doc-comment-model.d.ts

@@ -0,0 +1,23 @@
+export interface DocTagEntry {
+    readonly name: string;
+    readonly type: string | null;
+    readonly subject: string | null;
+    readonly text: string;
+}
+export interface ParsedDocComment {
+    readonly description: string;
+    readonly tags: readonly DocTagEntry[];
+}
+export declare const DOC_LINK_PREFIX = "#doc-link:";
+export declare function decodeEntities(text: string): string;
+export declare function safeAddress(address: string): string | null;
+export declare function htmlToMarkdown(source: string): string;
+export declare function inlineTagsToMarkdown(markdown: string): string;
+export declare function parseDocComment(body: string, options?: {
+    php?: boolean;
+}): ParsedDocComment;
+export interface DocTagSection {
+    readonly name: string;
+    readonly tags: readonly DocTagEntry[];
+}
+export declare function sectionsOf(tags: readonly DocTagEntry[]): DocTagSection[];

package/dist/doc-comment-model.js

@@ -0,0 +1,291 @@
+/*
+ * A documentation comment read the way a person reads it: a description and its tags. The text is
+ * Markdown by the time it leaves here. HTML is never passed on; a small, fixed subset is turned into
+ * Markdown and every other tag is dropped or left as text.
+ */
+/* The prefix of an address that stands for a name a `{@link}` points at, which the view resolves instead of following. */
+export const DOC_LINK_PREFIX = '#doc-link:';
+const ALIASES = {
+    returns: 'return',
+    exception: 'throws',
+    arg: 'param',
+    argument: 'param',
+    prop: 'property',
+    yields: 'yield',
+    link: 'see'
+};
+/* Tags that carry a type before their subject. */
+const TYPED = new Set(['param', 'property', 'return', 'throws', 'var', 'type', 'yield', 'template', 'this']);
+/* Tags whose first word is the thing they are about. */
+const SUBJECT_FIRST = new Set(['param', 'property', 'var', 'template']);
+const TAG_START = /^@([A-Za-z][\w-]*)(?::[\w-]+)?[ \t]*(.*)$/;
+const FENCE = /^\s*(```|~~~)/;
+const DASH = /^[—–-][ \t]+/;
+const DANGEROUS = /<(script|style|iframe|object|embed|svg|math|form)\b[\s\S]*?<\/\1\s*>|<\/?(script|style|iframe|object|embed|link|meta|base|svg|math|form|img|video|audio|source|input|button|textarea|select|canvas|frame|frameset)\b[^>]*>/gi;
+const SAFE_SCHEME = /^(https?:|mailto:)/i;
+/* Reads a type that starts the text: in braces as JSDoc writes it, or as one word with its brackets as PHPDoc does. */
+function takeType(text, braces) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith('{')) {
+        let depth = 0;
+        for (let i = 0; i < trimmed.length; i++) {
+            depth += trimmed[i] === '{' ? 1 : trimmed[i] === '}' ? -1 : 0;
+            if (depth === 0) {
+                return { type: trimmed.slice(1, i).trim(), rest: trimmed.slice(i + 1).trimStart() };
+            }
+        }
+        return { type: null, rest: trimmed };
+    }
+    if (braces || /^[$&.]/.test(trimmed)) {
+        return { type: null, rest: trimmed };
+    }
+    let depth = 0;
+    let end = 0;
+    for (; end < trimmed.length; end++) {
+        const character = trimmed[end];
+        if ('<([{'.includes(character)) {
+            depth++;
+        }
+        else if ('>)]}'.includes(character)) {
+            depth--;
+        }
+        else if (/\s/.test(character) && depth <= 0) {
+            break;
+        }
+    }
+    return { type: end === 0 ? null : trimmed.slice(0, end), rest: trimmed.slice(end).trimStart() };
+}
+/* The first word of a tag's text: a name with its sigils and the `[name=default]` form of JSDoc. */
+function takeSubject(text) {
+    const optional = /^\[([^\]]+)\]\s*/.exec(text);
+    if (optional !== null) {
+        return { subject: optional[1], rest: text.slice(optional[0].length) };
+    }
+    const word = /^(?:\.\.\.|&)?[$\w.\\:-]+/.exec(text);
+    if (word === null) {
+        return { subject: null, rest: text };
+    }
+    return { subject: word[0], rest: text.slice(word[0].length).trimStart() };
+}
+/* A comment's lines cut where a tag starts at the beginning of a line, outside a fenced block. */
+function splitTags(body) {
+    const description = [];
+    const raw = [];
+    let fenced = false;
+    for (const line of body.split('\n')) {
+        if (FENCE.test(line)) {
+            fenced = !fenced;
+        }
+        const start = fenced ? null : TAG_START.exec(line.trimStart());
+        if (start !== null) {
+            raw.push({ name: start[1].toLowerCase(), text: start[2] });
+        }
+        else if (raw.length > 0) {
+            raw[raw.length - 1].text += `\n${line}`;
+        }
+        else {
+            description.push(line);
+        }
+    }
+    return { description: description.join('\n').trim(), raw };
+}
+function entryOf(name, text, php) {
+    let rest = text.trim();
+    let type = null;
+    let subject = null;
+    if (TYPED.has(name)) {
+        const taken = name === 'return' && rest.startsWith('$this') ? { type: '$this', rest: rest.slice(5).trimStart() } : takeType(rest, !php);
+        type = taken.type;
+        rest = taken.rest;
+        // A type that stands alone is the whole text of a tag that has no subject.
+        if (SUBJECT_FIRST.has(name) || (name === 'throws' && type === null)) {
+            const word = takeSubject(rest);
+            subject = word.subject;
+            rest = word.rest;
+        }
+    }
+    else if (name === 'see' && !rest.startsWith('{')) {
+        const target = /^\S+/.exec(rest);
+        subject = target === null ? null : target[0];
+        rest = target === null ? rest : rest.slice(target[0].length).trimStart();
+    }
+    if (name === 'throws' && type === null && subject !== null) {
+        type = subject;
+        subject = null;
+    }
+    return { name, type, subject, text: rest.replace(DASH, '').trim() };
+}
+/* Text outside backtick code, which is the only text HTML and inline tags are read in. */
+function outsideCode(markdown, convert) {
+    return markdown
+        .split(/(```[\s\S]*?```|~~~[\s\S]*?~~~|`[^`\n]*`)/)
+        .map((part, index) => (index % 2 === 1 ? part : convert(part)))
+        .join('');
+}
+const ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'", nbsp: ' ', ndash: '-', mdash: '-', hellip: '...' };
+/* Named entities of the small set docblocks use, and numeric ones; anything else stays as written. */
+export function decodeEntities(text) {
+    return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, code) => {
+        if (code[0] === '#') {
+            const point = code[1].toLowerCase() === 'x' ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+            return Number.isFinite(point) && point > 0 && point <= 0x10ffff ? String.fromCodePoint(point) : match;
+        }
+        return ENTITIES[code.toLowerCase()] ?? match;
+    });
+}
+function dedent(text) {
+    const lines = text.replace(/^\n+|\s+$/g, '').split('\n');
+    const indents = lines.filter((line) => line.trim() !== '').map((line) => line.length - line.trimStart().length);
+    const common = indents.length === 0 ? 0 : Math.min(...indents);
+    return lines.map((line) => line.slice(common)).join('\n');
+}
+function fenced(body) {
+    return `\n\n\`\`\`\n${dedent(decodeEntities(stripTags(body)))}\n\`\`\`\n\n`;
+}
+function stripTags(html) {
+    return html.replace(/<\/?[a-zA-Z][^>]*>/g, '');
+}
+/* The address of a link when it is one a reader may follow; null for everything else, such as a script address. */
+export function safeAddress(address) {
+    const trimmed = decodeEntities(address.trim());
+    return SAFE_SCHEME.test(trimmed) || trimmed.startsWith(DOC_LINK_PREFIX) ? trimmed.replace(/\s/g, '%20').replace(/\(/g, '%28').replace(/\)/g, '%29') : null;
+}
+/*
+ * The HTML subset docblocks use, as Markdown: paragraphs and breaks, bold, italic, code, preformatted
+ * blocks, links to http, https and mailto, lists, headings and entities. Dangerous elements go with their
+ * content, attributes are never copied except a safe `href`, and a tag that is not in the subset is left
+ * as the text it was, which the view draws escaped.
+ */
+export function htmlToMarkdown(source) {
+    if (!source.includes('<') && !source.includes('&')) {
+        return source;
+    }
+    const lists = [];
+    const counters = [];
+    let anchor = null;
+    const blocks = source
+        .replace(/<pre\b[^>]*>([\s\S]*?)<\/pre\s*>/gi, (_match, body) => fenced(body))
+        .replace(/<code>([^<]*\n[^<]*)<\/code>/gi, (_match, body) => fenced(body));
+    const converted = outsideCode(blocks, (text) => text
+        .replace(DANGEROUS, '')
+        .replace(/<(\/?)(p|br|b|strong|i|em|u|code|tt|kbd|samp|var|a|ul|ol|li|h[1-6]|blockquote|hr|div|span|dl|dt|dd|sup|sub|small|center)\b([^>]*?)(\/?)>/gi, (_match, close, tag, attributes) => {
+        const closing = close === '/';
+        switch (tag.toLowerCase()) {
+            case 'p':
+            case 'div':
+            case 'dl':
+                return '\n\n';
+            case 'br':
+                return '\n';
+            case 'hr':
+                return '\n\n---\n\n';
+            case 'b':
+            case 'strong':
+                return '**';
+            case 'i':
+            case 'em':
+            case 'var':
+                return '*';
+            case 'code':
+            case 'tt':
+            case 'kbd':
+            case 'samp':
+                return '`';
+            case 'a': {
+                if (closing) {
+                    const target = anchor;
+                    anchor = null;
+                    return target === null ? '' : `](${target})`;
+                }
+                const href = /\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(attributes);
+                anchor = href === null ? null : safeAddress(href[1] ?? href[2] ?? href[3] ?? '');
+                return anchor === null ? '' : '[';
+            }
+            case 'ul':
+            case 'ol':
+                if (closing) {
+                    lists.pop();
+                    counters.pop();
+                }
+                else {
+                    lists.push(tag.toLowerCase());
+                    counters.push(0);
+                }
+                return '\n';
+            case 'li': {
+                if (closing) {
+                    return '';
+                }
+                const depth = Math.max(0, lists.length - 1);
+                const marker = lists.at(-1) === 'ol' ? `${(counters[depth] = (counters[depth] ?? 0) + 1)}.` : '-';
+                return `\n${'  '.repeat(depth)}${marker} `;
+            }
+            case 'blockquote':
+                return closing ? '\n\n' : '\n\n> ';
+            case 'dt':
+                return closing ? '**\n\n' : '\n\n**';
+            case 'dd':
+                return '\n\n';
+            default:
+                if (/^h[1-6]$/i.test(tag)) {
+                    return closing ? '\n\n' : `\n\n${'#'.repeat(Number(tag[1]))} `;
+                }
+                return '';
+        }
+    }));
+    // Entities last, so `&lt;b&gt;` stays the text it spells and is not read as a tag above.
+    return outsideCode(converted, decodeEntities).replace(/\n{3,}/g, '\n\n');
+}
+/*
+ * Inline `{@link Name}`, `{@link Name label}`, `{@link Name|label}`, the `linkcode` and `linkplain` forms, `{@see Name}`
+ * and `{@code text}`. A name becomes a link the view resolves; an address becomes a link to it.
+ */
+export function inlineTagsToMarkdown(markdown) {
+    return outsideCode(markdown, (text) => text
+        .replace(/\{@(?:link|linkcode|linkplain|see)\s+([^}\s|]+)(?:\s*[|\s]\s*([^}]+?))?\s*\}/g, (_match, target, label) => {
+        const address = /^https?:\/\//i.test(target) ? safeAddress(target) : `${DOC_LINK_PREFIX}${encodeURIComponent(target)}`;
+        const shown = label ?? target;
+        return address === null ? `\`${shown}\`` : `[${label === undefined ? `\`${shown}\`` : shown}](${address})`;
+    })
+        .replace(/\{@code\s+([^}]*)\}/g, (_match, code) => `\`${code.trim()}\``)
+        .replace(/\{@inheritDoc\}/g, ''));
+}
+/* An example's lines without the caption, and without the indentation they share; the text after the tag on its own line is not indented like the rest. */
+function exampleOf(text) {
+    const code = text.replace(/^\s*<caption>[\s\S]*?<\/caption>[ \t]*\n?/i, '');
+    const [head = '', ...tail] = code.split('\n');
+    return head.trim() === '' ? dedent(code) : [head.trim(), dedent(tail.join('\n'))].join('\n').trim();
+}
+function proseOf(text) {
+    return inlineTagsToMarkdown(htmlToMarkdown(text)).trim();
+}
+/* Reads the body of a documentation comment, as `findDocComments` returns it. `php` lets a type stand without braces. */
+export function parseDocComment(body, options = {}) {
+    const php = options.php === true;
+    const { description, raw } = splitTags(body);
+    const tags = raw.map(({ name, text }) => {
+        const bare = name.replace(/^(?:psalm|phpstan)-/, '');
+        const canonical = ALIASES[bare] ?? bare;
+        const entry = entryOf(canonical, text, php);
+        // An example is code: it keeps its lines and gets no prose treatment, only its caption removed.
+        if (canonical === 'example') {
+            return { ...entry, text: exampleOf(text) };
+        }
+        return { ...entry, text: proseOf(entry.text) };
+    });
+    return { description: proseOf(description), tags };
+}
+/* Tags in the order a reader looks for them; every other tag follows in the order it was written. */
+const ORDER = ['deprecated', 'template', 'param', 'property', 'type', 'var', 'return', 'yield', 'throws', 'see', 'example', 'since', 'version', 'author'];
+/* The tags gathered by name, so a list of parameters is one section, in reading order. */
+export function sectionsOf(tags) {
+    const byName = new Map();
+    for (const tag of tags) {
+        byName.set(tag.name, [...(byName.get(tag.name) ?? []), tag]);
+    }
+    const rank = (name) => {
+        const index = ORDER.indexOf(name);
+        return index === -1 ? ORDER.length : index;
+    };
+    return [...byName].map(([name, entries]) => ({ name, tags: entries })).sort((left, right) => rank(left.name) - rank(right.name));
+}

package/dist/editor-language.d.ts

@@ -1,12 +1,14 @@
 import { type Keymap } from '@adecore/editor/keymap';
 import type { Editor, EditorPosition } from '@adecore/editor';
 import type { Location } from '@adecore/lsp';
+import { CallHierarchyFeature } from './call-hierarchy.ts';
 import { CodeActionsFeature } from './code-actions.ts';
 import { CodeVisionFeature } from './code-vision.ts';
 import { CompletionFeature } from './completion.ts';
 import { ContextMenuFeature } from './context-menu.ts';
 import { DefinitionLinkFeature } from './definition-link.ts';
 import { DiagnosticsFeature } from './diagnostics.ts';
+import { FormatOnTypeFeature } from './format-on-type.ts';
 import { HighlightsFeature } from './highlights.ts';
 import { HistoryFeature } from './history.ts';
 import { HoverFeature } from './hover.ts';
@@ -15,13 +17,19 @@ import { PeekFeature } from './peek.ts';
 import { PickFeature } from './pick.ts';
 import { SymbolPickerFeature } from './symbol-picker.ts';
 import { RenameFeature } from './rename.ts';
+import { RenderedDocsFeature } from './rendered-docs.ts';
 import { shortcutsOf } from './shortcut-keys.ts';
 import { type Timers } from './timers.ts';
+import { InlayHintsFeature } from './inlay-hints.ts';
+import { type SemanticTokensOptions } from './semantic-tokens.ts';
 import { SignatureFeature } from './signature.ts';
 import { SnippetFeature } from './snippet-session.ts';
 import { SymbolsFeature } from './symbols.ts';
 import type { Place } from './navigation-history.ts';
 import type { LanguageDocumentHandle, ProjectLanguage } from './project-language.ts';
+export interface EditorLanguageOptions {
+    semanticTokens?: SemanticTokensOptions;
+}
 export declare class EditorLanguage {
     readonly editor: Editor;
     readonly apple: boolean;
@@ -33,6 +41,7 @@ export declare class EditorLanguage {
     readonly popups: import("./popups.ts").PopupStore;
     readonly diagnostics: DiagnosticsFeature;
     readonly hover: HoverFeature;
+    readonly inlayHints: InlayHintsFeature;
     readonly completion: CompletionFeature;
     readonly signature: SignatureFeature;
     readonly snippets: SnippetFeature;
@@ -42,15 +51,18 @@ export declare class EditorLanguage {
     readonly rename: RenameFeature;
     readonly navigation: NavigationFeature;
     readonly peek: PeekFeature;
+    readonly callHierarchy: CallHierarchyFeature;
     readonly symbolPicker: SymbolPickerFeature;
     readonly contextMenu: ContextMenuFeature;
     readonly history: HistoryFeature;
     readonly definitionLink: DefinitionLinkFeature;
     readonly symbols: SymbolsFeature;
     readonly codeVision: CodeVisionFeature;
+    readonly formatOnType: FormatOnTypeFeature;
+    readonly renderedDocs: RenderedDocsFeature;
     private readonly disposers;
     private disposed;
-    constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers?: Timers);
+    constructor(project: ProjectLanguage, editor: Editor, uri: string, languageId: string, timers?: Timers, options?: EditorLanguageOptions);
     get uri(): string;
     get isDisposed(): boolean;
     get place(): Place;

package/dist/editor-language.js

@@ -1,4 +1,5 @@
 import { KEYMAP } from '@adecore/editor/keymap';
+import { CallHierarchyFeature } from './call-hierarchy.js';
 import { CodeActionsFeature } from './code-actions.js';
 import { CodeVisionFeature } from './code-vision.js';
 import { CompletionFeature } from './completion.js';
@@ -6,6 +7,7 @@ import { ContextMenuFeature } from './context-menu.js';
 import { DefinitionLinkFeature } from './definition-link.js';
 import { DiagnosticsFeature } from './diagnostics.js';
 import { FoldingFeature } from './folding.js';
+import { FormatOnTypeFeature } from './format-on-type.js';
 import { HighlightsFeature } from './highlights.js';
 import { HistoryFeature } from './history.js';
 import { HoverFeature } from './hover.js';
@@ -14,6 +16,7 @@ import { PeekFeature } from './peek.js';
 import { PickFeature } from './pick.js';
 import { SymbolPickerFeature } from './symbol-picker.js';
 import { RenameFeature } from './rename.js';
+import { RenderedDocsFeature } from './rendered-docs.js';
 import { shortcutsOf } from './shortcut-keys.js';
 import { createPopupStore } from './popups.js';
 import { realTimers } from './timers.js';
@@ -39,6 +42,7 @@ export class EditorLanguage {
     popups = createPopupStore();
     diagnostics;
     hover;
+    inlayHints;
     completion;
     signature;
     snippets;
@@ -48,15 +52,18 @@ export class EditorLanguage {
     rename;
     navigation;
     peek;
+    callHierarchy;
     symbolPicker;
     contextMenu;
     history;
     definitionLink;
     symbols;
     codeVision;
+    formatOnType;
+    renderedDocs;
     disposers = [];
     disposed = false;
-    constructor(project, editor, uri, languageId, timers = realTimers) {
+    constructor(project, editor, uri, languageId, timers = realTimers, options = {}) {
         this.editor = editor;
         this.apple = project.host.apple ?? false;
         this.keymap = project.host.keymap ?? KEYMAP;
@@ -68,22 +75,25 @@ export class EditorLanguage {
         this.diagnostics = new DiagnosticsFeature(this);
         this.hover = new HoverFeature(this, timers);
         this.completion = new CompletionFeature(this, timers);
-        this.snippets = new SnippetFeature(this);
+        this.snippets = new SnippetFeature(this, timers);
         this.signature = new SignatureFeature(this, timers);
         this.highlights = new HighlightsFeature(this, timers);
         this.symbols = new SymbolsFeature(this, timers);
         new SelectionRangesFeature(this);
-        new SemanticTokensFeature(this, timers);
-        new InlayHintsFeature(this, timers);
+        new SemanticTokensFeature(this, timers, options.semanticTokens);
+        this.inlayHints = new InlayHintsFeature(this, timers);
         this.codeActions = new CodeActionsFeature(this, timers);
         this.rename = new RenameFeature(this);
         this.navigation = new NavigationFeature(this);
-        this.peek = new PeekFeature(this);
+        this.peek = new PeekFeature(this, timers);
+        this.callHierarchy = new CallHierarchyFeature(this, timers);
         this.symbolPicker = new SymbolPickerFeature(this);
         this.contextMenu = new ContextMenuFeature(this);
         this.history = new HistoryFeature(this);
         this.definitionLink = new DefinitionLinkFeature(this);
         this.codeVision = new CodeVisionFeature(this, (listener) => this.symbols.onResult(listener), timers);
+        this.formatOnType = new FormatOnTypeFeature(this);
+        this.renderedDocs = new RenderedDocsFeature(this, timers);
         new FoldingFeature(this, (listener) => this.symbols.onResult(listener), timers);
         this.placeOpenedCaret(editor.getCaret());
         this.onDispose(editor.onCaret((position) => this.placeOpenedCaret(position)));