@adecore/editor 0.22.1 → 0.23.1

package/dist/touch.js

@@ -0,0 +1,100 @@
+/* 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;
+/*
+ * 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 {
+    contact;
+    timer;
+    lastTap;
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    /* Whether the finger that is down held still long enough to select a word. */
+    get pressed() {
+        return this.contact?.pressed === true;
+    }
+    start(event, area = 'text', taken) {
+        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) {
+        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) {
+        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() {
+        this.cancel();
+    }
+    tap(contact, event) {
+        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 }]);
+    }
+    press() {
+        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 }]);
+    }
+    clearTimer() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        this.timer = undefined;
+    }
+    cancel() {
+        this.clearTimer();
+        this.contact = undefined;
+    }
+}

package/dist/types.d.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';
 export type { EditorCommand, FoldRole };
@@ -14,6 +15,7 @@ export interface EditorFolds {
 }
 export type EditorTheme = string;
 export interface EditorOptions {
+    readonly handBack?: readonly KeyChord[];
     readonly text: string;
     readonly language?: string;
     readonly path?: string;
@@ -24,9 +26,11 @@ export interface EditorOptions {
     readonly indentation?: EditorIndentation;
     readonly smartKeys?: Partial<EditorSmartKeys>;
     readonly guides?: boolean;
+    readonly stickyScroll?: boolean;
     readonly whitespace?: boolean;
     readonly rightMargin?: number | null;
     readonly foldOutline?: EditorFoldOutline;
+    readonly folding?: boolean;
     readonly messages?: Partial<EditorMessages>;
     readonly label?: string;
     readonly folds?: EditorFolds;
@@ -37,6 +41,12 @@ export interface EditorOptions {
 }
 export interface EditorMessages {
     readonly noMoreOccurrences: string;
+    readonly fold: string;
+    readonly unfold: string;
+}
+export interface EditorInputPopup {
+    readonly controls: string;
+    readonly activeDescendant?: string;
 }
 export interface EditorSmartKeys {
     readonly autoPairBrackets: boolean;
@@ -93,8 +103,11 @@ export interface EditorLineHighlight {
     readonly color: EditorMarkColor;
     readonly fill?: EditorMarkColor;
     readonly sign?: string;
+    readonly bar?: 'solid' | 'hatched';
+    readonly emphasis?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>;
 }
 export interface EditorCodeBlockOptions {
+    readonly tokens?: ReadonlyArray<readonly LineToken[]> | null;
     readonly firstLine?: number;
     readonly sign?: string;
     readonly color?: EditorMarkColor;
@@ -117,9 +130,14 @@ export interface EditorContentChange {
     readonly range: EditorRange;
     readonly text: string;
 }
+export interface EditorApplyEditsOptions {
+    readonly mapSelections?: (range: EditorRange) => EditorRange;
+    readonly mergeUndo?: boolean;
+}
 export interface EditorTextChange {
     readonly changes: readonly EditorContentChange[];
     readonly source: 'input' | 'command' | 'external';
+    readonly typed?: boolean;
 }
 export type EditorMarkerSeverity = 'error' | 'warning' | 'info' | 'hint';
 export interface EditorMarker {
@@ -162,6 +180,17 @@ export interface EditorWidget {
     readonly line: number;
     readonly placement?: 'above' | 'below';
     readonly height?: number;
+    readonly fixed?: boolean;
+    render(container: HTMLElement): void;
+}
+export interface EditorReplacement {
+    readonly id: string;
+    readonly startLine: number;
+    readonly endLine: number;
+    readonly height?: number;
+    readonly label?: string;
+    readonly enterable?: boolean;
+    onReveal?(): void;
     render(container: HTMLElement): void;
 }
 export interface EditorLineAction {
@@ -187,6 +216,7 @@ export interface EditorSemanticToken {
     readonly character: number;
     readonly length: number;
     readonly scopes: readonly string[];
+    readonly within?: LineTokenKind;
 }
 export interface ScopeStyle {
     readonly color: string;
@@ -197,7 +227,26 @@ export type ScopeColorSource = (theme: EditorTheme) => Promise<ScopeColors | nul
 export interface EditorInlayHint {
     readonly position: EditorPosition;
     readonly label: string;
+    readonly id?: string;
+    readonly parts?: readonly string[];
+    readonly paddingLeft?: boolean;
+    readonly paddingRight?: boolean;
+}
+export interface EditorInlayTarget {
+    readonly id: string;
+    readonly part: number | null;
+    readonly rect: EditorRect;
+}
+export interface EditorInlayClick {
+    readonly id: string;
+    readonly part: number | null;
+    readonly mod: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+    readonly clicks: 1 | 2;
+    readonly touch: boolean;
 }
+export type EditorInlayClickHandler = (click: EditorInlayClick) => boolean;
 export interface EditorGhostText {
     readonly position: EditorPosition;
     readonly text: string;
@@ -207,10 +256,13 @@ export interface EditorGutterAction {
     readonly line: number;
     readonly label: string;
 }
+export type EditorGutterIcon = 'sparkles' | 'book-open';
 export interface EditorGutterMarker {
     readonly id: string;
     readonly line: number;
     readonly label: string;
+    readonly icon?: EditorGutterIcon;
+    readonly pressed?: boolean;
 }
 export type EditorReveal = 'relative' | 'center' | 'centerDown' | 'centerUp';
 export interface EditorIndentation {
@@ -228,6 +280,13 @@ export interface EditorFindState {
     readonly count: number;
     readonly current: number | null;
     readonly noSelection?: boolean;
+    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;
+    readonly large?: boolean;
 }
 export interface EditorReplaceOptions {
     readonly preserveCase?: boolean;
@@ -251,6 +310,7 @@ export interface Editor {
     findStep(direction: 1 | -1): void;
     replace(replacement: string, options?: EditorReplaceOptions): boolean;
     replaceAll(replacement: string, options?: EditorReplaceOptions): number;
+    replaceAllAsync(replacement: string, options?: EditorReplaceOptions): Promise<number>;
     setReplacePreview(replacement: string | null, options?: EditorReplaceOptions): void;
     selectFindMatches(): number;
     findFromCursor(query: EditorFindQuery, direction: 1 | -1): boolean;
@@ -260,17 +320,21 @@ export interface Editor {
     setIndentation(indentation: EditorIndentation): void;
     setSmartKeys(keys: Partial<EditorSmartKeys>): void;
     setGuides(guides: boolean): void;
+    setStickyScroll?(sticky: boolean): void;
     setWhitespace(whitespace: boolean): void;
     setRightMargin(column: number | null): void;
     setFoldOutline(outline: EditorFoldOutline): void;
     setLabel(label: string): void;
     setFoldHints(hints: EditorFoldHints | null): void;
-    setChangeMarks(marks: readonly EditorChangeMark[]): void;
+    setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void;
     setBlocks(blocks: readonly EditorBlock[] | null): void;
     onScope(listener: (scope: readonly EditorBlock[]) => void): () => void;
     setAttributionMarks(marks: readonly EditorAttributionMark[]): void;
     setRemoteCursors(cursors: readonly EditorRemoteCursor[]): void;
     setLineHighlights(highlights: readonly EditorLineHighlight[]): void;
+    setLineNumbers(labels: ((line: number) => string | null) | null): void;
+    setLineLabels(labels: ((line: number) => string | null) | null): void;
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void;
     renderCode(container: HTMLElement, text: string, options?: EditorCodeBlockOptions): void;
     onAttributionHover(listener: (hover: EditorAttributionHover | null) => void): () => void;
     setMarkers(markers: readonly EditorMarker[]): void;
@@ -278,6 +342,12 @@ export interface Editor {
     setLink(range: EditorRange | null): void;
     setSemanticTokens(tokens: readonly EditorSemanticToken[] | null): void;
     setInlayHints(hints: readonly EditorInlayHint[]): void;
+    onInlayHover?(listener: (target: EditorInlayTarget | null) => void): () => void;
+    onInlayClick?(handler: EditorInlayClickHandler): () => void;
+    setInlayLink?(target: {
+        readonly id: string;
+        readonly part: number | null;
+    } | null): void;
     setGhostText(ghost: EditorGhostText | null): void;
     setGutterAction(action: EditorGutterAction | null): void;
     onGutterAction(listener: (line: number) => void): () => void;
@@ -285,6 +355,11 @@ export interface Editor {
     onGutterMarker(listener: (id: string) => void): () => void;
     getCaret(): EditorPosition;
     getScrollTop(): number;
+    setScrollTop(top: number): void;
+    getLineHeight(line: number): number;
+    getBaseLineHeight?(): number;
+    onLineHeights(listener: () => void): () => void;
+    getContentHeight(): number;
     getFolds(): EditorFolds;
     getSelection(): EditorRange;
     getSelections(): EditorRange[];
@@ -292,12 +367,16 @@ export interface Editor {
     setCaret(position: EditorPosition, reveal?: EditorReveal): void;
     setSelection(range: EditorRange, reveal?: EditorReveal): void;
     setSelections(ranges: readonly EditorRange[], reveal?: EditorReveal): void;
+    setInputPopup(popup: EditorInputPopup | null): void;
+    announce(message: string): void;
+    setMessages(messages: Partial<EditorMessages>): void;
     onCaret(listener: (position: EditorPosition) => void): () => void;
     onHover(listener: (hover: EditorHover | null) => void): () => void;
     rectAt(position: EditorPosition): EditorRect | null;
     getVisibleRange(): EditorRange;
     onViewChange(listener: () => void): () => void;
     setWidgets(widgets: readonly EditorWidget[], owner?: string): void;
+    setReplacements?(replacements: readonly EditorReplacement[], owner?: string): void;
     setLineActions(actions: readonly EditorLineAction[], owner?: string): void;
     setCodeVision(rows: readonly EditorCodeVision[]): void;
     onClick(handler: EditorClickHandler): () => void;
@@ -305,10 +384,11 @@ export interface Editor {
     onKeyDown(handler: EditorKeyHandler): () => void;
     setSelectionRanges(provider: EditorSelectionRanges | null): void;
     trackRange(range: EditorRange): EditorTrackedRange;
-    applyEdits(edits: readonly EditorContentChange[]): boolean;
+    applyEdits(edits: readonly EditorContentChange[], options?: EditorApplyEditsOptions): boolean;
     setTheme(theme: EditorTheme): void;
     refreshFont(): void;
     setReadOnly(readOnly: boolean, reason?: string): void;
+    isReadOnly?(): boolean;
     runCommand(command: EditorRunCommand): boolean;
     focus(): void;
     dispose(): void;
@@ -328,7 +408,9 @@ export interface LineToken {
     readonly length: number;
     readonly color: string;
     readonly fontStyle: number;
+    readonly kind?: LineTokenKind;
 }
+export type LineTokenKind = 'comment' | 'string' | 'regex';
 export interface TokenizedLine {
     readonly tokens: readonly LineToken[];
     readonly state: unknown;
@@ -337,9 +419,11 @@ export interface LineTokenizer {
     tokenizeLine(text: string, state: unknown): TokenizedLine;
     sameState(a: unknown, b: unknown): boolean;
     stale?(): boolean;
+    prepare?(text: string): Promise<boolean>;
 }
 export type TokenizerSource = (language: string | undefined, theme: EditorTheme, text?: string) => Promise<LineTokenizer | null>;
 export interface SmartEditorEngineOptions {
+    readonly searchWorker?: EditorSearchClientOptions['workerFactory'];
     readonly keymap?: Keymap;
     readonly tokenizer: TokenizerSource;
     readonly scopeColors?: ScopeColorSource;

package/dist/uniform-geometry.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutMetrics, LineGeometry } from './layout.ts';
+export declare function uniformGeometry(line: {
+    start: number;
+    end: number;
+    text: string;
+    next?: number;
+}, metrics: LayoutMetrics, breaks: number[], triggers: number[], indent: number): LineGeometry | null;

package/dist/uniform-geometry.js

@@ -0,0 +1,49 @@
+export function uniformGeometry(line, metrics, breaks, triggers, indent) {
+    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, length) => {
+        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 = {
+        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;
+}

package/dist/view.d.ts

@@ -1,10 +1,12 @@
 import { type DocumentModel, type FoldHints, type FoldRole, type FoldingRange, type Selection as EditorSelection } from '@adecore/editor-core';
+import { type EditorSearchClientOptions } from './search-client.ts';
 import { FindController } from './find.ts';
-import { type BlockWidget, EditorLayout, type Inlay } from './layout.ts';
+import { type BlockReplacement, type BlockWidget, EditorLayout, type Inlay } from './layout.ts';
 import { type ScrollKind } from './scroll.ts';
 import { TokenCache } from './tokens.ts';
-import type { EditorBlock, EditorChangeMark, EditorCodeBlockOptions, EditorFindQuery, EditorFindState, EditorHighlightKind, EditorMarkerSeverity, EditorMessages, EditorRect, EditorSmartKeys, LineTokenizer, ScopeColors } from './types.ts';
+import type { EditorBlock, EditorChangeMark, EditorCodeBlockOptions, EditorFindQuery, EditorFindState, EditorHighlightKind, EditorInputPopup, EditorLineHighlight, EditorGutterIcon, EditorMarkerSeverity, EditorMessages, EditorRect, EditorSmartKeys, LineToken, LineTokenKind, LineTokenizer, ScopeColors } from './types.ts';
 export interface ViewSettings {
+    searchWorker?: EditorSearchClientOptions['workerFactory'];
     language: string | undefined;
     tabSize: number;
     insertSpaces: boolean;
@@ -18,6 +20,8 @@ export interface ViewSettings {
     whitespace: boolean;
     rightMargin: number | null;
     foldOutline: 'off' | 'hover' | 'always';
+    folding?: boolean;
+    stickyScroll?: boolean;
 }
 export type ViewFold = Omit<FoldingRange, 'kind'> & {
     kind: FoldingRange['kind'] | 'custom';
@@ -31,6 +35,14 @@ export interface ViewSemanticToken {
     from: number;
     to: number;
     scopes: readonly string[];
+    within?: LineTokenKind;
+}
+export interface GutterMarker {
+    id: string;
+    line: number;
+    label: string;
+    icon?: EditorGutterIcon;
+    pressed?: boolean;
 }
 export interface ViewMarker {
     severity: EditorMarkerSeverity;
@@ -58,6 +70,7 @@ export declare class EditorView {
     private readonly preview;
     private readonly signs;
     private readonly notice;
+    private readonly live;
     private readonly sticky;
     private readonly overview;
     private readonly tickTip;
@@ -69,10 +82,17 @@ export declare class EditorView {
     private readonly findListeners;
     private readonly scopeListeners;
     private readonly viewListeners;
+    private readonly lineHeightListeners;
+    private announcedLineHeights;
     private readonly gutterActionListeners;
     private gutterAction;
     private readonly gutterMarkerListeners;
     private readonly gutterMarkers;
+    private lineTokenProvider;
+    private lineNumberProvider;
+    private lineNumberLabels;
+    private lineNumberRevision;
+    private lineNumberWidth;
     private semantic;
     private scopeColors;
     private semanticVersion;
@@ -86,8 +106,9 @@ export declare class EditorView {
     private readonly outline;
     private stickyEntries;
     private scopeKey;
-    private changeMarks;
+    private readonly changeLayers;
     private changeVersion;
+    private changeCache;
     private readonly attribution;
     private readonly highlights;
     private remoteCarets;
@@ -111,8 +132,13 @@ export declare class EditorView {
     private frameGeometry;
     private disposed;
     private inlays;
+    private readonly inlayHoverListeners;
+    private inlayHover;
+    private inlayLink;
+    private inlayLinkElement;
     private readonly blocks;
     private lenses;
+    private readonly replacements;
     private occurrences;
     private replacePreview;
     private dropCaret;
@@ -133,6 +159,8 @@ export declare class EditorView {
     private foldTimer;
     private colorTimer;
     private noticeTimer;
+    private liveTimer;
+    private lineLabelProvider;
     private bracketCache;
     private wrapWidth;
     private rowEndCaret;
@@ -141,10 +169,17 @@ export declare class EditorView {
     readonly settings: ViewSettings;
     constructor(container: HTMLElement, model: DocumentModel, settings: ViewSettings);
     applySettings(): void;
+    repaint(): void;
     refreshFont(): void;
     setTokenizer(tokenizer: LineTokenizer | null): void;
+    grammarChanged(): void;
+    setLineTokens(tokens: ((line: number) => readonly LineToken[] | null | undefined) | null): void;
+    setLineNumbers(labels: ((line: number) => string | null) | null): void;
+    private lineNumberLabel;
     setInlays(inlays: readonly Inlay[]): void;
     setBlockWidgets(owner: string, blocks: readonly BlockWidget[]): void;
+    setReplacements(owner: string, replacements: readonly BlockReplacement[]): void;
+    private allReplacements;
     setLenses(lenses: readonly BlockWidget[]): void;
     private allBlocks;
     setOccurrences(occurrences: readonly Occurrence[]): void;
@@ -159,10 +194,15 @@ export declare class EditorView {
     setMarkers(markers: readonly ViewMarker[]): void;
     setComposition(text: string | undefined): void;
     notify(message: string): void;
+    private foldName;
+    announce(message: string): void;
+    setInputPopup(popup: EditorInputPopup | null): void;
+    setLineLabels(labels: ((line: number) => string | null) | null): void;
     get gutterElement(): HTMLElement;
     get stickyElement(): HTMLElement;
     focus(): void;
     get focused(): boolean;
+    get contentHeight(): number;
     get viewportHeight(): number;
     private get scrollTop();
     private get scrollLeft();
@@ -272,6 +312,9 @@ export declare class EditorView {
     markRowEnd(offset: number): void;
     onHover(listener: (offset: number | null) => void): () => void;
     private selectionOccurrences;
+    private get paintWindow();
+    private paintRectangles;
+    private visibleTextBounds;
     private wrapSigns;
     private indentOf;
     private effectiveIndent;
@@ -283,7 +326,26 @@ export declare class EditorView {
     setColumnMode(on: boolean): void;
     setDropCaret(offset: number | null): void;
     hoverMoved(event: PointerEvent): void;
+    inlayAt(target: EventTarget | null): {
+        id: string;
+        part: number | null;
+        element: HTMLElement;
+    } | null;
+    setInlayHover(target: EventTarget | null): void;
+    onInlayHover(listener: (target: {
+        id: string;
+        part: number | null;
+        rect: EditorRect;
+    } | null) => void): () => void;
+    setInlayLink(target: {
+        id: string;
+        part: number | null;
+    } | null): void;
+    private applyInlayLink;
     setHover(offset: number | null): void;
+    getLineHeight(line: number): number;
+    onLineHeights(listener: () => void): () => void;
+    setScrollTop(top: number): void;
     onViewChange(listener: () => void): () => void;
     private announceView;
     private caretOf;
@@ -309,8 +371,8 @@ export declare class EditorView {
     scrolled(): void;
     render(): void;
     private paintDecorations;
-    setChangeMarks(marks: readonly EditorChangeMark[]): void;
-    private markedLines;
+    setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void;
+    private resolvedChanges;
     private changedLines;
     setRemoteCarets(carets: readonly {
         id: string;
@@ -331,13 +393,7 @@ export declare class EditorView {
         endLine: number;
         color: string;
     }[]): void;
-    setLineHighlights(highlights: readonly {
-        startLine: number;
-        endLine: number;
-        color: string;
-        sign?: string;
-        fill?: string;
-    }[]): void;
+    setLineHighlights(highlights: readonly EditorLineHighlight[]): void;
     private highlightedLines;
     private highlightMarks;
     renderCode(container: HTMLElement, text: string, options: EditorCodeBlockOptions): void;
@@ -369,11 +425,7 @@ export declare class EditorView {
         label: string;
     } | null): void;
     onGutterAction(listener: (line: number) => void): () => void;
-    setGutterMarkers(owner: string, markers: readonly {
-        id: string;
-        line: number;
-        label: string;
-    }[]): void;
+    setGutterMarkers(owner: string, markers: readonly GutterMarker[]): void;
     onGutterMarker(listener: (id: string) => void): () => void;
     gutterMarkerIdOf(target: EventTarget | null): string | null;
     pressGutterMarker(id: string): void;