@adecore/editor 0.22.1 → 0.23.1

package/src/testing.ts

@@ -52,6 +52,8 @@ export interface KeyOptions {
     metaKey?: boolean;
     altKey?: boolean;
     shiftKey?: boolean;
+    /* 'touch', 'pen' or 'mouse' for a pointer event. */
+    pointerType?: string;
 }
 
 /* Fires a keydown at the element and says whether the editor took the key. */

package/src/tokens.ts

@@ -26,6 +26,8 @@ export class TokenCache {
     private entries: (Entry | undefined)[] = [];
     /* Every line above it is colored for the text as it is now. */
     private frontier = 0;
+    /* Colors survive a rebuild, but the states below this boundary cannot settle recoloring. */
+    private staleFrom = Number.POSITIVE_INFINITY;
     /* The last line the edit touched; lines below it may be told right by their old state. */
     private reusableFrom = Number.POSITIVE_INFINITY;
     /* The state the last line of the edited stretch ended in before the edit; the same state now means the lines below are right. */
@@ -48,6 +50,7 @@ export class TokenCache {
         this.tokenizer = tokenizer;
         this.lines = this.source.getLineCount();
         this.entries = [];
+        this.staleFrom = Number.POSITIVE_INFINITY;
         this.frontier = 0;
         this.forgetPivot();
     }
@@ -90,6 +93,7 @@ export class TokenCache {
         const first = batches[0]?.[0];
         if (first === undefined) {
             this.entries = [];
+            this.staleFrom = Number.POSITIVE_INFINITY;
             this.frontier = 0;
             this.forgetPivot();
             return;
@@ -104,8 +108,20 @@ export class TokenCache {
         const lastNew = last === undefined ? -1 : lineOf(last.from + shift + last.insertedLength);
         const lastOld = lastNew - delta;
         this.frontier = Math.min(this.frontier, firstLine);
+        if (last === undefined && Number.isFinite(this.staleFrom)) {
+            // A history batch has no single mapping for the old grammar boundary.
+            this.staleFrom = 0;
+            this.frontier = 0;
+        } else if (this.staleFrom > lastOld) {
+            this.staleFrom += delta;
+        } else if (this.staleFrom > firstLine) {
+            this.staleFrom = firstLine;
+        }
         if (last === undefined || lastOld < firstLine || this.entries.length <= firstLine) {
             this.entries.length = Math.min(this.entries.length, firstLine);
+            if (this.staleFrom >= this.entries.length) {
+                this.staleFrom = Number.POSITIVE_INFINITY;
+            }
             this.forgetPivot();
             return;
         }
@@ -116,6 +132,17 @@ export class TokenCache {
         this.reusableFrom = lastNew + 1;
     }
 
+    /* Old colors stay visible until the rebuilt grammar reaches each line. */
+    revalidate(): boolean {
+        if (this.tokenizer?.stale?.() !== true) {
+            return false;
+        }
+        this.frontier = 0;
+        this.staleFrom = 0;
+        this.forgetPivot();
+        return true;
+    }
+
     /*
      * Colors lines from the frontier until `until` is reached, the colors are right for the rest of
      * the document, or `budget` milliseconds are spent. Returns the first line that changed, so a
@@ -126,10 +153,7 @@ export class TokenCache {
         if (tokenizer === null) {
             return null;
         }
-        if (tokenizer.stale?.() === true) {
-            this.frontier = 0;
-            this.forgetPivot();
-        }
+        this.revalidate();
         const count = this.source.getLineCount();
         const limit = Math.min(until, count - 1);
         const deadline = now() + budget;
@@ -148,11 +172,16 @@ export class TokenCache {
             }
             this.entries[line] = next;
             this.frontier = line + 1;
+            const fresh = line < this.staleFrom;
+            if (line === this.staleFrom) {
+                this.staleFrom = line + 1 >= this.entries.length ? Number.POSITIVE_INFINITY : line + 1;
+            }
             const settled =
-                (line === this.pivotLine && tokenizer.sameState(this.pivotState, next.state)) ||
-                (previous !== undefined && line >= this.reusableFrom && tokenizer.sameState(previous.state, next.state));
+                fresh &&
+                ((line === this.pivotLine && tokenizer.sameState(this.pivotState, next.state)) ||
+                    (previous !== undefined && line >= this.reusableFrom && tokenizer.sameState(previous.state, next.state)));
             if (settled) {
-                this.frontier = this.entries.length;
+                this.frontier = Math.min(this.entries.length, this.staleFrom);
                 this.forgetPivot();
                 break;
             }

package/src/touch.ts

@@ -0,0 +1,134 @@
+import type { DocumentModel } from '@adecore/editor-core';
+
+export interface TouchHost {
+    readonly model: DocumentModel;
+    offsetAt(clientX: number, clientY: number): number;
+    camelHumps(): boolean;
+    /* The lines a tap on a line number selects, whole. */
+    lineAt(offset: number): { from: number; to: number };
+    focus(): void;
+}
+
+/* A finger that moves further than this, in pixels, is scrolling and not tapping. */
+const TAP_SLOP = 10;
+/* A finger held still this long selects the word under it. */
+const LONG_PRESS_MS = 500;
+/* A second tap this soon after the first, this close to it, is a double tap. */
+const DOUBLE_TAP_MS = 300;
+const DOUBLE_TAP_DISTANCE = 30;
+
+interface Contact {
+    id: number;
+    x: number;
+    y: number;
+    area: 'text' | 'gutter';
+    moved: boolean;
+    pressed: boolean;
+    /* Asked when the finger lifts as a tap, so a scroll never reaches a handler of the host. */
+    taken?: () => boolean;
+}
+
+/*
+ * A finger on the text. The viewport scrolls natively, so a drag is left to the browser and makes no
+ * selection; a tap places the caret, a double tap or a long press selects a word.
+ */
+export class TouchSelection {
+    private contact: Contact | undefined;
+    private timer: ReturnType<typeof setTimeout> | undefined;
+    private lastTap: { time: number; x: number; y: number } | undefined;
+    private readonly host: TouchHost;
+
+    constructor(host: TouchHost) {
+        this.host = host;
+    }
+
+    /* Whether the finger that is down held still long enough to select a word. */
+    get pressed(): boolean {
+        return this.contact?.pressed === true;
+    }
+
+    start(event: PointerEvent, area: 'text' | 'gutter' = 'text', taken?: () => boolean): void {
+        this.cancel();
+        this.contact = { id: event.pointerId, x: event.clientX, y: event.clientY, area, moved: false, pressed: false, taken };
+        if (area === 'text') {
+            this.timer = setTimeout(() => this.press(), LONG_PRESS_MS);
+        }
+    }
+
+    move(event: PointerEvent): void {
+        const contact = this.contact;
+        if (contact === undefined || event.pointerId !== contact.id || contact.moved) {
+            return;
+        }
+        if (Math.abs(event.clientX - contact.x) > TAP_SLOP || Math.abs(event.clientY - contact.y) > TAP_SLOP) {
+            contact.moved = true;
+            this.clearTimer();
+        }
+    }
+
+    /* The finger lifted: a tap that did not scroll and was not a long press lands here. */
+    end(event: PointerEvent): void {
+        const contact = this.contact;
+        if (contact === undefined || event.pointerId !== contact.id) {
+            return;
+        }
+        this.cancel();
+        if (event.type === 'pointercancel' || contact.moved || contact.pressed) {
+            return;
+        }
+        this.tap(contact, event);
+    }
+
+    dispose(): void {
+        this.cancel();
+    }
+
+    private tap(contact: Contact, event: PointerEvent): void {
+        const { model } = this.host;
+        const offset = this.host.offsetAt(contact.x, contact.y);
+        this.host.focus();
+        if (contact.area === 'gutter') {
+            const line = this.host.lineAt(offset);
+            model.setSelections([{ anchor: line.from, head: line.to }]);
+            return;
+        }
+        if (contact.taken?.()) {
+            return;
+        }
+        const last = this.lastTap;
+        const double =
+            last !== undefined &&
+            event.timeStamp - last.time <= DOUBLE_TAP_MS &&
+            Math.abs(contact.x - last.x) <= DOUBLE_TAP_DISTANCE &&
+            Math.abs(contact.y - last.y) <= DOUBLE_TAP_DISTANCE;
+        this.lastTap = double ? undefined : { time: event.timeStamp, x: contact.x, y: contact.y };
+        const word = double ? model.wordSelectionAt(offset, this.host.camelHumps()) : null;
+        model.setSelections([word === null ? { anchor: offset, head: offset } : { anchor: word.from, head: word.to }]);
+    }
+
+    private press(): void {
+        const contact = this.contact;
+        this.timer = undefined;
+        if (contact === undefined || contact.moved) {
+            return;
+        }
+        contact.pressed = true;
+        this.lastTap = undefined;
+        const offset = this.host.offsetAt(contact.x, contact.y);
+        const word = this.host.model.wordSelectionAt(offset, this.host.camelHumps());
+        this.host.focus();
+        this.host.model.setSelections([word === null ? { anchor: offset, head: offset } : { anchor: word.from, head: word.to }]);
+    }
+
+    private clearTimer(): void {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        this.timer = undefined;
+    }
+
+    private cancel(): void {
+        this.clearTimer();
+        this.contact = undefined;
+    }
+}

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { EditorSearchClientOptions } from './search-client.ts';
 import type { Keymap } from './keymap-table.ts';
 import type { EditorCommand, FoldRole } from '@adecore/editor-core';
 
@@ -44,6 +45,8 @@ export interface EditorFolds {
 export type EditorTheme = string;
 
 export interface EditorOptions {
+    /* Additional host shortcuts for this mount, preserving the engine's handBack chords. */
+    readonly handBack?: readonly KeyChord[];
     readonly text: string;
     /* A Shiki language id. Without one, or with one Shiki does not know, it is plain text. */
     readonly language?: string;
@@ -60,12 +63,16 @@ export interface EditorOptions {
     readonly smartKeys?: Partial<EditorSmartKeys>;
     /* A line at each indentation level, the one of the scope around the caret stronger; on unless false. */
     readonly guides?: boolean;
+    /* The headers of the blocks scrolled out of sight stay pinned on top; on unless false. */
+    readonly stickyScroll?: boolean;
     /* Spaces drawn as dots and tabs as arrows; off unless true. */
     readonly whitespace?: boolean;
     /* The column to draw a line at, such as the `max_line_length` of a project; none by default. */
     readonly rightMargin?: number | null;
     /* When the arrow that folds a block shows in the gutter; on hover by default. */
     readonly foldOutline?: EditorFoldOutline;
+    /* False disables automatic and selection folds, including fold commands. */
+    readonly folding?: boolean;
     /* What the editor says to a person itself, in the host's words. */
     readonly messages?: Partial<EditorMessages>;
     /* The accessible name of the editor, such as "Commit message", in the host's language; `Code editor` without one. */
@@ -86,6 +93,18 @@ export interface EditorOptions {
 export interface EditorMessages {
     /* Select next occurrence went past the last one. */
     readonly noMoreOccurrences: string;
+    /* The name of a gutter control that folds a block; `{start}` and `{end}` are the one-based first and last line. `Fold lines {start} to {end}` without one. */
+    readonly fold: string;
+    /* The same for the control that unfolds it; `Unfold lines {start} to {end}` without one. */
+    readonly unfold: string;
+}
+
+/* The list a host opens beside the text that the keyboard picks from, such as suggestions, as the input points at it for assistive technology. */
+export interface EditorInputPopup {
+    /* The id of the element that holds the options. */
+    readonly controls: string;
+    /* The id of the option that Enter takes; none while the list has no active option. */
+    readonly activeDescendant?: string;
 }
 
 /* What the editor does by itself as a person types. Every one is on, except the camel humps. */
@@ -193,10 +212,20 @@ export interface EditorLineHighlight {
     readonly fill?: EditorMarkColor;
     /* A character in the gutter of each line, such as `+`, in the same color. */
     readonly sign?: string;
+    /*
+     * Draws the gutter of each line as a review does: the cell tinted in `color`, the number in a readable
+     * shade of it and a bar of whole pixels along the left edge, solid or striped, continuous over
+     * consecutive lines. It takes the place of the change mark on those lines.
+     */
+    readonly bar?: 'solid' | 'hatched';
+    /* Per line from `startLine`, UTF-16 character ranges with a stronger tint; they follow their text through edits. */
+    readonly emphasis?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>;
 }
 
 /* How `renderCode` draws lines that are not part of the document. */
 export interface EditorCodeBlockOptions {
+    /* Prepared in the source document's grammar state. Omit to tokenize here; null draws plain text. */
+    readonly tokens?: ReadonlyArray<readonly LineToken[]> | null;
     /* One-based number of the first line, shown in the gutter column; without it the lines have none. */
     readonly firstLine?: number;
     /* A character in the gutter of each line, such as `-`. */
@@ -233,11 +262,18 @@ export interface EditorContentChange {
     readonly text: string;
 }
 
+export interface EditorApplyEditsOptions {
+    readonly mapSelections?: (range: EditorRange) => EditorRange;
+    readonly mergeUndo?: boolean;
+}
+
 export interface EditorTextChange {
     /* In order, so a language server can follow them one by one. */
     readonly changes: readonly EditorContentChange[];
     /* A person typing, one of the editor's own commands such as undo, or a change from outside. */
     readonly source: 'input' | 'command' | 'external';
+    /* Set when a person's typing made the change though it ran as a command, as Enter does; every change from the keyboard has source `input` without it. */
+    readonly typed?: boolean;
 }
 
 export type EditorMarkerSeverity = 'error' | 'warning' | 'info' | 'hint';
@@ -308,6 +344,32 @@ export interface EditorWidget {
     readonly placement?: 'above' | 'below';
     /* The height the row has until it has been measured. */
     readonly height?: number;
+    /* Uses height as exact pixels and never measures the row. */
+    readonly fixed?: boolean;
+    /* Fills the element the row is drawn in, which the editor makes again whenever the row scrolls back into view. */
+    render(container: HTMLElement): void;
+}
+
+/*
+ * Lines of the text drawn as a row of the host's own DOM instead, such as a documentation comment drawn
+ * as formatted text. The lines stay in the document: copying, searching and the undo history see them as
+ * they are, and the row is as tall as its content. Put the caret on one of the lines, or fold them,
+ * and the editor draws the text again; it is for the host to take the row away at that moment when it
+ * wants the lines edited.
+ */
+export interface EditorReplacement {
+    readonly id: string;
+    /* Zero-based and inclusive; the row follows its lines through edits until its owner sets its replacements again. */
+    readonly startLine: number;
+    readonly endLine: number;
+    /* The height the row has until it has been measured. */
+    readonly height?: number;
+    /* What assistive technology calls the row. */
+    readonly label?: string;
+    /* Whether the caret may stop in the row's lines when it moves up or down. Without it a vertical move steps over the row. */
+    readonly enterable?: boolean;
+    /* The editor is about to scroll to a place inside the row's lines. The host shows the lines itself here, so the target is where the person will see it. */
+    onReveal?(): void;
     /* Fills the element the row is drawn in, which the editor makes again whenever the row scrolls back into view. */
     render(container: HTMLElement): void;
 }
@@ -362,6 +424,8 @@ export interface EditorSemanticToken {
     readonly length: number;
     /* Outermost first, as a grammar would have reported them. */
     readonly scopes: readonly string[];
+    /* Colors only the stretches of text the grammar classed as this kind, such as a server's SQL tokens inside a string. */
+    readonly within?: LineTokenKind;
 }
 
 /* How a theme draws a piece of code. The font style is Shiki's flags: 1 italic, 2 bold, 4 underline, 8 strikethrough. */
@@ -380,8 +444,41 @@ export type ScopeColorSource = (theme: EditorTheme) => Promise<ScopeColors | nul
 export interface EditorInlayHint {
     readonly position: EditorPosition;
     readonly label: string;
+    /* Names the hint in `onInlayHover` and `onInlayClick`; `hint-<index>` without one. */
+    readonly id?: string;
+    /* The label cut into pieces that the pointer tells apart; they add up to `label`. */
+    readonly parts?: readonly string[];
+    /* A gap of 4 pixels that keeps the pill off the character before it or the one after it. */
+    readonly paddingLeft?: boolean;
+    readonly paddingRight?: boolean;
 }
 
+/* A hint, or one part of its label, under the pointer. */
+export interface EditorInlayTarget {
+    readonly id: string;
+    /* The index into `parts`, or null for a hint without parts or the padding of one. */
+    readonly part: number | null;
+    /* The hint or part, in screen coordinates. */
+    readonly rect: EditorRect;
+}
+
+/* A press of the primary button on a hint. */
+export interface EditorInlayClick {
+    readonly id: string;
+    readonly part: number | null;
+    /* Cmd on macOS, Ctrl elsewhere. */
+    readonly mod: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    /* 2 for a second press on the same hint within half a second. */
+    readonly clicks: 1 | 2;
+    /* A finger, which has no hover; a press then stands in for it. */
+    readonly touch: boolean;
+}
+
+/* Returns true when the press was taken; the editor then leaves the caret and the selection where they are. */
+export type EditorInlayClickHandler = (click: EditorInlayClick) => boolean;
+
 /*
  * A suggestion drawn after the caret in the editor's ghost color, which is not part of the document. It
  * may span lines. Any edit of the text takes it away, so the host sets it again for the text it was made for.
@@ -401,6 +498,9 @@ export interface EditorGutterAction {
     readonly label: string;
 }
 
+/* The glyphs a gutter marker can have. */
+export type EditorGutterIcon = 'sparkles' | 'book-open';
+
 /* A small button in the gutter on one line that the host keeps apart from the code action, such as the mark of a saved inline edit. */
 export interface EditorGutterMarker {
     /* What `onGutterMarker` says when it is pressed. */
@@ -408,6 +508,10 @@ export interface EditorGutterMarker {
     /* Zero-based; it stays on this line until the host sets its markers again. */
     readonly line: number;
     readonly label: string;
+    /* The glyph; the sparkles without one. */
+    readonly icon?: EditorGutterIcon;
+    /* Drawn as switched on, for a marker that toggles something. */
+    readonly pressed?: boolean;
 }
 
 /*
@@ -435,10 +539,19 @@ export interface EditorFindQuery {
 
 export interface EditorFindState {
     readonly count: number;
-    /* Zero-based; null without a match. */
+    /* Zero-based in the marked cache; null with no match or a current match beyond that cache. */
     readonly current: number | null;
     /* The search is in the selection and nothing was selected. */
     readonly noSelection?: boolean;
+    /* More results exist than the marked count. */
+    readonly limited?: boolean;
+    readonly searching?: boolean;
+    readonly failed?: 'invalid' | 'timeout' | 'unavailable' | 'error';
+    readonly captureFailed?: 'timeout' | 'unavailable' | 'error';
+    readonly replaceFailed?: 'limit' | 'timeout' | 'unavailable' | 'error';
+    readonly replaced?: number;
+    /* Regex searches in large documents start only on an explicit step. */
+    readonly large?: boolean;
 }
 
 export interface EditorReplaceOptions {
@@ -484,15 +597,17 @@ export interface Editor {
      */
     find(query: EditorFindQuery | null): void;
     findStep(direction: 1 | -1): void;
-    /* Replaces the match the find is on, with `$1` and the like expanded for a regular expression, and moves to the next one. False when there is none or the editor is read only. */
+    /* Replaces the match the find is on, with `$1` and the like expanded for a regular expression, and moves to the next one. Regex returns true when the worker operation starts; false when there is no match or the editor is read only. */
     replace(replacement: string, options?: EditorReplaceOptions): boolean;
-    /* Replaces every match in one undo step, and says how many there were. */
+    /* Complete literal results return the number replaced; otherwise starts asynchronous replacement, returns zero and reports through onFind. */
     replaceAll(replacement: string, options?: EditorReplaceOptions): number;
+    /* Atomic, one undo step; excessive output or matches are refused through onFind. */
+    replaceAllAsync(replacement: string, options?: EditorReplaceOptions): Promise<number>;
     /* What a regular expression replacement writes for the match the find is on, drawn under it while the find is open; null takes it away. */
     setReplacePreview(replacement: string | null, options?: EditorReplaceOptions): void;
     /* Ends the find with a caret on every match, the one the find was on last, and says how many there were. */
     selectFindMatches(): number;
-    /* Selects the next match of a query from the cursor, or the one before, going round at the ends, without a find bar. False when there is none. */
+    /* Selects the next match of a query from the cursor, or the one before, going round at the ends, without a find bar. Regex returns true when the worker request starts; literal returns whether a match was selected. */
     findFromCursor(query: EditorFindQuery, direction: 1 | -1): boolean;
     onFind(listener: (state: EditorFindState) => void): () => void;
     /* Takes the marks away and selects the match the find was on, so the cursor is where it stopped. */
@@ -502,6 +617,8 @@ export interface Editor {
     /* Changes what it does as a person types; the keys left out stay as they are. */
     setSmartKeys(keys: Partial<EditorSmartKeys>): void;
     setGuides(guides: boolean): void;
+    /* Optional so an editor from before it still fits. */
+    setStickyScroll?(sticky: boolean): void;
     setWhitespace(whitespace: boolean): void;
     /* The column to draw a line at; null takes it away. */
     setRightMargin(column: number | null): void;
@@ -509,8 +626,12 @@ export interface Editor {
     setLabel(label: string): void;
     /* What a language server knows about the folds: the bodies of symbols and the ranges it folds. They follow their text through edits until set again; null forgets them. */
     setFoldHints(hints: EditorFoldHints | null): void;
-    /* Marks that follow their lines through edits until the host sets them again. */
-    setChangeMarks(marks: readonly EditorChangeMark[]): void;
+    /*
+     * Marks that follow their lines through edits until the host sets them again. Every layer (default: the unnamed one)
+     * holds its own marks and the editor draws the union, so setting one layer never clears another; an empty list
+     * removes the layer. On a line two layers mark, the later one wins, in the order the layers last became non-empty.
+     */
+    setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void;
     /*
      * The blocks sticky scroll and the breadcrumb go by. The editor reads them from brackets and
      * indentation until the host has better, such as a language server's symbols; null goes back.
@@ -528,6 +649,16 @@ export interface Editor {
     setRemoteCursors(cursors: readonly EditorRemoteCursor[]): void;
     /* Lines tinted behind the text, replacing the ones set before. They follow their text through edits until set again, and cost one mapping of two offsets per highlight. */
     setLineHighlights(highlights: readonly EditorLineHighlight[]): void;
+    /* Source labels for zero-based document lines; a null label hides the number. Null restores document numbering. */
+    setLineNumbers(labels: ((line: number) => string | null) | null): void;
+    /*
+     * A visually hidden sentence for zero-based document lines that assistive technology reads with the line
+     * number, such as "Added, new line 12". A line with one hides its drawn number from assistive
+     * technology, so the sentence carries the number too. Null removes them.
+     */
+    setLineLabels(labels: ((line: number) => string | null) | null): void;
+    /* Prepared colors for displayed lines. Unknown or null results stay plain; null restores grammar tokenization. Keep the same array while a line is unchanged; call again when results change. */
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void;
     /*
      * Fills a widget row's element with lines of code that are not in the document, such as the lines an
      * agent removed, in the editor's face and colors for the language, a gutter column as wide as the
@@ -546,6 +677,12 @@ export interface Editor {
     setSemanticTokens(tokens: readonly EditorSemanticToken[] | null): void;
     /* Hints to draw as soft pills in the text, replacing the ones set before. They follow their text through edits until set again. */
     setInlayHints(hints: readonly EditorInlayHint[]): void;
+    /* The pointer moved onto a hint or one of its parts, or null when it left them. Optional so an editor from before it still fits. */
+    onInlayHover?(listener: (target: EditorInlayTarget | null) => void): () => void;
+    /* Handlers see a press of the primary button on a hint before the editor does, the first to take it winning. */
+    onInlayClick?(handler: EditorInlayClickHandler): () => void;
+    /* Draws a hint or one of its parts as a link, underlined with a pointing hand, until the host sets another or the hints are set again; null takes it away. */
+    setInlayLink?(target: { readonly id: string; readonly part: number | null } | null): void;
     /* A suggestion after the caret, replacing the one before; null takes it away. Any change of the text takes it away as well. */
     setGhostText(ghost: EditorGhostText | null): void;
     /* One button in the gutter, replacing the one before; null takes it away. It stays on its line until the host sets it again. */
@@ -559,6 +696,16 @@ export interface Editor {
     getCaret(): EditorPosition;
     /* In pixels, what `scrollTop` on mounting takes back. */
     getScrollTop(): number;
+    /* Immediate pixels, canceling an animated scroll and repainting before returning. */
+    setScrollTop(top: number): void;
+    /* Intrinsic text height of a zero-based line, estimated until drawn; zero for hidden or absent lines. */
+    getLineHeight(line: number): number;
+    /* The height of one line of text, as the font and the line height setting make it, which a row of the host or a fold never changes. */
+    getBaseLineHeight?(): number;
+    /* Text heights changed after a measurement, edit, wrap width or font change; excludes widget heights. */
+    onLineHeights(listener: () => void): () => void;
+    /* All rows in pixels, including the horizontal scrollbar, for a host that grows with its contents. */
+    getContentHeight(): number;
     /* Which lines are folded, for `folds` on mounting. */
     getFolds(): EditorFolds;
     /* The primary selection, start before end; empty at the caret. */
@@ -572,6 +719,12 @@ export interface Editor {
     setSelection(range: EditorRange, reveal?: EditorReveal): void;
     /* Replaces the selections with these, in the order given: the last is the primary one, as for the newest caret, and is scrolled into view. An empty list changes nothing. */
     setSelections(ranges: readonly EditorRange[], reveal?: EditorReveal): void;
+    /* Points the input at a list the host shows, so assistive technology reads its active option while focus stays in the text; null when the list closes. */
+    setInputPopup(popup: EditorInputPopup | null): void;
+    /* Says a sentence politely to assistive technology without drawing anything. Saying the same sentence again is heard again. */
+    announce(message: string): void;
+    /* Replaces the sentences the editor says on its own, such as the names of the fold controls. */
+    setMessages(messages: Partial<EditorMessages>): void;
     /* The caret moved or the text under it changed. */
     onCaret(listener: (position: EditorPosition) => void): () => void;
     /* The pointer moved onto another character, or null when it left the text. */
@@ -590,6 +743,12 @@ export interface Editor {
      * set its rows last. An empty list takes the owner's rows away.
      */
     setWidgets(widgets: readonly EditorWidget[], owner?: string): void;
+    /*
+     * Lines drawn as rows of the host's own DOM, replacing the ones the same owner set before; other
+     * owners keep theirs. Where two owners claim the same first line the owner that sorts first keeps
+     * it, and a line the person folded draws its fold instead. Optional so an editor from before it still fits.
+     */
+    setReplacements?(replacements: readonly EditorReplacement[], owner?: string): void;
     /* The actions of one owner (`default` without one), replacing the ones it set before and leaving every other owner's alone. A line that a fold hides has none. */
     setLineActions(actions: readonly EditorLineAction[], owner?: string): void;
     /* The code vision rows above declarations, replacing the ones set before. Separate from the widgets, which they never displace. */
@@ -604,12 +763,14 @@ export interface Editor {
     setSelectionRanges(provider: EditorSelectionRanges | null): void;
     /* Follows a range through every change of the text, `setText` and undo included, until it is disposed. Costs one mapping of two offsets per change. */
     trackRange(range: EditorRange): EditorTrackedRange;
-    /* Replaces ranges of the current text at once, as one step of the undo history. */
-    applyEdits(edits: readonly EditorContentChange[]): boolean;
+    /* Replaces ranges of the current text at once, as one step of the undo history. `mapSelections` places each selection in the new text, keeping its direction, and redo restores it. `mergeUndo` joins the step before it when the text is exactly as that step left it, so one undo takes both back. */
+    applyEdits(edits: readonly EditorContentChange[], options?: EditorApplyEditsOptions): boolean;
     setTheme(theme: EditorTheme): void;
     /* Reads the code face off the page again, after the page changed its size, family or ligatures. */
     refreshFont(): void;
     setReadOnly(readOnly: boolean, reason?: string): void;
+    /* Whether the editor refuses edits. Optional so an editor from before it still fits. */
+    isReadOnly?(): boolean;
     /* Runs an editing command on every caret, as its key would. False when it changed nothing. */
     runCommand(command: EditorRunCommand): boolean;
     focus(): void;
@@ -639,8 +800,13 @@ export interface LineToken {
     readonly color: string;
     /* Bit flags as Shiki writes them: 1 italic, 2 bold, 4 underline, 8 strikethrough. */
     readonly fontStyle: number;
+    /* What the grammar says the stretch is, when it says so; absent for plain code. */
+    readonly kind?: LineTokenKind;
 }
 
+/* The classes of text a grammar tells apart from code. */
+export type LineTokenKind = 'comment' | 'string' | 'regex';
+
 export interface TokenizedLine {
     readonly tokens: readonly LineToken[];
     /* What the next line starts from; only the tokenizer that made it reads it. */
@@ -657,12 +823,16 @@ export interface LineTokenizer {
     sameState(a: unknown, b: unknown): boolean;
     /* True once, when the grammar was rebuilt and the states handed out before it are void. */
     stale?(): boolean;
+    /* Loads missing embedded grammars named by text; true when a load can invalidate earlier states. */
+    prepare?(text: string): Promise<boolean>;
 }
 
 /* A tokenizer for a language in a theme, or null when there is no grammar for it. May load the grammar, so it is async; `text` is the document, for the embedded languages it names. */
 export type TokenizerSource = (language: string | undefined, theme: EditorTheme, text?: string) => Promise<LineTokenizer | null>;
 
 export interface SmartEditorEngineOptions {
+    /* One lazy search worker per mounted editor; regex search is unavailable without it. */
+    readonly searchWorker?: EditorSearchClientOptions['workerFactory'];
     readonly keymap?: Keymap;
     readonly tokenizer: TokenizerSource;
     /* Without it semantic tokens are ignored and the grammar's colors stand. */

package/src/uniform-geometry.ts

@@ -0,0 +1,57 @@
+import type { LayoutMetrics, LineGeometry } from './layout.ts';
+
+export function uniformGeometry(
+    line: { start: number; end: number; text: string; next?: number },
+    metrics: LayoutMetrics,
+    breaks: number[],
+    triggers: number[],
+    indent: number
+): LineGeometry | null {
+    const rowStarts = [0, ...breaks];
+    const firstLength = rowStarts[1] ?? line.text.length;
+    let continuationLength = 0;
+    for (let row = 1; row < rowStarts.length; row++) {
+        continuationLength = Math.max(continuationLength, (rowStarts[row + 1] ?? line.text.length) - rowStarts[row]!);
+    }
+    // A shared prefix preserves repeated floating-point addition exactly, even for fallback font metrics.
+    if (Math.max(firstLength, continuationLength) > 4096) {
+        return null;
+    }
+    const positions = (start: number, length: number): number[] => {
+        const result = [start];
+        for (let index = 0; index < length; index++) {
+            result.push(result.at(-1)! + metrics.charWidth);
+        }
+        return result;
+    };
+    const uniform = { first: positions(0, firstLength), continuation: positions(indent, continuationLength) };
+    const geometry: LineGeometry = {
+        start: line.start,
+        end: line.end,
+        next: line.next ?? line.end,
+        text: line.text,
+        offsets: [],
+        before: [],
+        after: [],
+        rowOf: [],
+        rowStarts,
+        rowEnds: [],
+        rowTriggers: triggers,
+        runs: [],
+        inlays: [],
+        subRows: rowStarts.length,
+        width: 0,
+        uniform
+    };
+    for (let row = 0; row < rowStarts.length; row++) {
+        const from = rowStarts[row]!;
+        const to = rowStarts[row + 1] ?? line.text.length;
+        const end = uniform[row === 0 ? 'first' : 'continuation'][to - from]!;
+        geometry.rowEnds.push(end);
+        geometry.width = Math.max(geometry.width, end);
+        if (from < to) {
+            geometry.runs.push({ from, to, x: row === 0 ? 0 : indent, subRow: row, text: line.text.slice(from, to) });
+        }
+    }
+    return geometry;
+}