@adecore/editor 0.42.0 → 0.44.0

package/dist/keymap-table.js

@@ -15,10 +15,15 @@ export const KEYMAP = {
     deleteLine: bind('Mod+Backspace', 'Mod+Y'),
     moveLineUp: bind('Alt+Shift+ArrowUp'),
     moveLineDown: bind('Alt+Shift+ArrowDown'),
+    moveStatementUp: bind('Mod+Shift+ArrowUp'),
+    moveStatementDown: bind('Mod+Shift+ArrowDown'),
     toggleLineComment: bind('Mod+/'),
     toggleBlockComment: bind('Mod+Alt+/', 'Mod+Shift+/'),
     joinLines: bind('Ctrl+Shift+J'),
     startNewLine: bind('Shift+Enter'),
+    completeCurrentStatement: bind('Mod+Shift+Enter'),
+    hippieCompletion: bind('Alt+/'),
+    hippieBackwardCompletion: bind('Alt+Shift+/'),
     startNewLineBefore: bind('Mod+Alt+Enter'),
     splitLine: bind('Mod+Enter'),
     toggleCase: bind('Mod+Shift+U'),
@@ -30,8 +35,21 @@ export const KEYMAP = {
     convertIndentsToSpaces: bind(null),
     convertIndentsToTabs: bind(null),
     expandSelection: bind('Alt+ArrowUp', 'Ctrl+W'),
-    shrinkSelection: bind('Alt+ArrowDown'),
+    // Off macOS Alt+ArrowDown is Next Method, as in IntelliJ, so Shrink Selection takes its own chord there.
+    shrinkSelection: bind('Alt+ArrowDown', 'Ctrl+Shift+W'),
     matchBrace: bind('Ctrl+M', 'Ctrl+Shift+M'),
+    methodUp: bind('Ctrl+Shift+ArrowUp', 'Alt+ArrowUp'),
+    methodDown: bind('Ctrl+Shift+ArrowDown', 'Alt+ArrowDown'),
+    lastEditLocation: bind('Mod+Shift+Backspace'),
+    nextEditLocation: bind(null),
+    pasteFromHistory: bind('Mod+Shift+V'),
+    pasteAsPlainText: bind('Mod+Alt+Shift+V'),
+    nextChange: bind('Ctrl+Alt+Shift+ArrowDown'),
+    previousChange: bind('Ctrl+Alt+Shift+ArrowUp'),
+    codeBlockStart: bind('Mod+Alt+[', 'Ctrl+['),
+    codeBlockEnd: bind('Mod+Alt+]', 'Ctrl+]'),
+    codeBlockStartWithSelection: bind('Mod+Alt+Shift+[', 'Ctrl+Shift+['),
+    codeBlockEndWithSelection: bind('Mod+Alt+Shift+]', 'Ctrl+Shift+]'),
     selectNextOccurrence: bind('Ctrl+G', 'Alt+J'),
     unselectOccurrence: bind('Ctrl+Shift+G', 'Alt+Shift+J'),
     selectAllOccurrences: bind('Meta+Ctrl+G', 'Ctrl+Alt+Shift+J'),
@@ -51,9 +69,10 @@ export const KEYMAP = {
     smartEnd: bind('Meta+ArrowRight', null),
     selectSmartEnd: bind('Meta+Shift+ArrowRight', null),
     textStart: bind('Meta+ArrowUp', null),
-    selectTextStart: bind('Meta+Shift+ArrowUp', null),
+    // IntelliJ binds Cmd+Shift+ArrowUp and ArrowDown to Move Statement on macOS, where Cmd+Shift+Home and End still select to the text edges.
+    selectTextStart: bind(null),
     textEnd: bind('Meta+ArrowDown', null),
-    selectTextEnd: bind('Meta+Shift+ArrowDown', null),
+    selectTextEnd: bind(null),
     collapse: bind('Mod+-'),
     expand: bind('Mod+='),
     collapseAll: bind('Mod+Shift+-'),
@@ -81,6 +100,13 @@ export const KEYMAP = {
     renameSymbol: bind('Shift+F6'),
     organizeImports: bind('Ctrl+Alt+O'),
     formatDocument: bind('Mod+Alt+L'),
+    insertLiveTemplate: bind('Mod+J'),
+    surroundWith: bind('Mod+Alt+T'),
+    surroundWithLiveTemplate: bind('Mod+Alt+J'),
+    unwrap: bind('Mod+Shift+Delete'),
+    saveAsLiveTemplate: bind(null),
+    // Surround with Emmet has no chord of its own: it is a row of Surround with Live Template, which has this one.
+    wrapWithAbbreviation: bind(null),
     selectionToChat: bind(null),
     inlineEdit: bind(null),
     suggestInline: bind(null),
@@ -92,6 +118,7 @@ export const KEYMAP = {
     peekDefinition: bind('Alt+Space', 'Ctrl+Shift+I'),
     peekReferences: bind('Alt+F7'),
     callHierarchy: bind('Ctrl+Alt+H'),
+    typeHierarchy: bind('Ctrl+H'),
     toggleRenderedDocs: bind('Ctrl+Alt+Q'),
     historyBack: bind('Mod+[', 'Ctrl+Alt+ArrowLeft'),
     historyForward: bind('Mod+]', 'Ctrl+Alt+ArrowRight'),

package/dist/keymap.js

@@ -16,10 +16,15 @@ const ACTIONS = {
     deleteLine: command('deleteLine'),
     moveLineUp: command('moveLineUp'),
     moveLineDown: command('moveLineDown'),
+    moveStatementUp: command('moveStatementUp'),
+    moveStatementDown: command('moveStatementDown'),
     toggleLineComment: command('toggleLineComment'),
     toggleBlockComment: command('toggleBlockComment'),
     joinLines: command('joinLines'),
     startNewLine: command('startNewLine'),
+    completeCurrentStatement: command('completeCurrentStatement'),
+    hippieCompletion: command('hippieCompletion'),
+    hippieBackwardCompletion: command('hippieBackwardCompletion'),
     startNewLineBefore: command('startNewLineBefore'),
     splitLine: command('splitLine'),
     toggleCase: command('toggleCase'),
@@ -32,6 +37,15 @@ const ACTIONS = {
     expandSelection: command('expandSelection'),
     shrinkSelection: command('shrinkSelection'),
     matchBrace: { type: 'bracket' },
+    methodUp: view('methodUp'),
+    methodDown: view('methodDown'),
+    pasteAsPlainText: view('pasteAsPlainText'),
+    nextChange: view('nextChange'),
+    previousChange: view('previousChange'),
+    codeBlockStart: command('codeBlockStart'),
+    codeBlockEnd: command('codeBlockEnd'),
+    codeBlockStartWithSelection: command('codeBlockStartWithSelection'),
+    codeBlockEndWithSelection: command('codeBlockEndWithSelection'),
     selectNextOccurrence: command('selectNextOccurrence'),
     unselectOccurrence: command('unselectOccurrence'),
     selectAllOccurrences: command('selectAllOccurrences'),

package/dist/layout.d.ts

@@ -36,7 +36,9 @@ export interface Inlay {
     gapRight?: number;
     composition?: boolean;
     ghost?: boolean;
+    swatch?: string;
 }
+export declare const SWATCH_SIZE = 12;
 export interface BlockWidget {
     id: string;
     at: number;

package/dist/layout.js

@@ -11,6 +11,8 @@ export function subRowBand(top, subRows, lineHeight, window, block = 1) {
         last: Math.min(subRows - 1, Math.ceil((last + 1) / block) * block - 1)
     };
 }
+/* The side of a swatch in pixels, without its gaps. */
+export const SWATCH_SIZE = 12;
 export const TEXT_PADDING = 0;
 export const BOTTOM_PADDING = 8;
 export const RIGHT_PADDING = 16;
@@ -154,9 +156,12 @@ export function scanDenseLine(line, metrics, limit, lineInlays) {
             flushRun(offset);
             const inlay = lineInlays[nextInlay++];
             const shown = visibleBidi(inlay.text);
+            const gaps = (inlay.gapLeft ?? 0) + (inlay.gapRight ?? 0);
             const width = inlay.composition || inlay.ghost
                 ? metrics.measureText(shown)
-                : Math.max(8, metrics.measureInlay(shown) + 12) + (inlay.gapLeft ?? 0) + (inlay.gapRight ?? 0);
+                : inlay.swatch !== undefined
+                    ? SWATCH_SIZE + gaps
+                    : Math.max(8, metrics.measureInlay(shown) + 12) + gaps;
             geometry.inlays.push({ inlay, x, width, subRow: row });
             x += width;
         }

package/dist/outline.d.ts

@@ -37,6 +37,7 @@ export declare class Outline {
     setStructure(entries: OutlineEntry[]): void;
     setProvided(blocks: readonly EditorBlock[] | null, document: OutlineDocument): void;
     edited(batches: readonly (readonly DocumentChange[])[]): void;
+    declarationStops(document: OutlineDocument): number[];
     blocks(document: OutlineDocument): readonly OutlineBlock[];
 }
 export interface StickyRows {

package/dist/outline.js

@@ -140,6 +140,16 @@ export class Outline {
         this.provided = this.provided === null ? null : move(this.provided);
         this.version++;
     }
+    /* Where the named blocks of the structure declare their name, in no order: the stops of Method Up and Down. */
+    declarationStops(document) {
+        return this.structure.flatMap((entry) => {
+            if (entry.name === undefined) {
+                return [];
+            }
+            const header = document.getLine(document.positionAt(entry.from).line);
+            return [header.start + Math.max(0, header.text.indexOf(entry.name))];
+        });
+    }
     /* Outermost first. Of two blocks that start on one line, only the larger one. */
     blocks(document) {
         if (this.cache?.version !== this.version) {

package/dist/paint.js

@@ -102,10 +102,20 @@ export function lineElement(document, geometry, tokens, lineHeight, band, whites
             continue;
         }
         const span = document.createElement('span');
-        span.className = box.inlay.ghost ? 'se-ghost' : box.inlay.composition ? 'se-composition' : 'se-inlay';
+        span.className = box.inlay.ghost
+            ? 'se-ghost'
+            : box.inlay.composition
+                ? 'se-composition'
+                : box.inlay.swatch !== undefined
+                    ? 'se-inlay se-swatch'
+                    : 'se-inlay';
         span.dataset.inlayId = box.inlay.id;
         const { parts } = box.inlay;
-        if (parts === undefined) {
+        if (box.inlay.swatch !== undefined) {
+            span.style.backgroundColor = box.inlay.swatch;
+            span.setAttribute('aria-label', box.inlay.text);
+        }
+        else if (parts === undefined) {
             span.textContent = visibleBidi(box.inlay.text);
         }
         else {

package/dist/text-queries.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentModel } from '@adecore/editor-core';
+import type { EditorPosition, EditorPostfixOperand, EditorRange, EditorSurroundShape, EditorTextPlace, EditorUnwrapTarget } from './types.ts';
+export interface Coordinates {
+    positionAt(offset: number): EditorPosition;
+    offsetAt(position: EditorPosition): number;
+}
+export declare function placeAt(model: DocumentModel, coordinates: Coordinates, position: EditorPosition, language: string): EditorTextPlace;
+export declare function postfixOperands(model: DocumentModel, coordinates: Coordinates, dot: EditorPosition, language: string): EditorPostfixOperand[];
+export declare function surroundShape(model: DocumentModel, coordinates: Coordinates, range: EditorRange, language: string): EditorSurroundShape | null;
+export declare function unwrapTargets(model: DocumentModel, coordinates: Coordinates, position: EditorPosition, language: string, indentUnit: string): EditorUnwrapTarget[];

package/dist/text-queries.js

@@ -0,0 +1,24 @@
+function rangeOf(coordinates, from, to) {
+    return { start: coordinates.positionAt(from), end: coordinates.positionAt(to) };
+}
+export function placeAt(model, coordinates, position, language) {
+    return model.placeAt(coordinates.offsetAt(position), language);
+}
+export function postfixOperands(model, coordinates, dot, language) {
+    const at = coordinates.offsetAt(dot);
+    return model.postfixOperands(at, language).map((operand) => ({
+        range: rangeOf(coordinates, operand.from, operand.from + model.slice(operand.from, at).trimEnd().length),
+        statement: operand.statement
+    }));
+}
+export function surroundShape(model, coordinates, range, language) {
+    const shape = model.surroundShape(coordinates.offsetAt(range.start), coordinates.offsetAt(range.end), language);
+    return shape === null ? null : { range: rangeOf(coordinates, shape.from, shape.to), statements: shape.statements, expression: shape.expression };
+}
+export function unwrapTargets(model, coordinates, position, language, indentUnit) {
+    return model.unwrapTargets(coordinates.offsetAt(position), language, indentUnit).map((target) => ({
+        kind: target.kind,
+        range: rangeOf(coordinates, target.range.from, target.range.to),
+        edits: target.edits.map((edit) => ({ range: rangeOf(coordinates, edit.from, edit.to), text: edit.text }))
+    }));
+}

package/dist/types.d.ts

@@ -1,10 +1,10 @@
 import type { EditorSearchClientOptions } from './search-client.ts';
 import type { Keymap } from './keymap-table.ts';
-import type { EditorCommand, FoldRole, WhitespaceCleanupOptions } from '@adecore/editor-core';
+import type { EditorCommand, FoldRole, TextPlaceKind, UnwrapKind, WhitespaceCleanupOptions } from '@adecore/editor-core';
 export type { EditorCommand, FoldRole };
 export type EditorWhitespaceCleanup = WhitespaceCleanupOptions;
 export type EditorFoldOutline = 'off' | 'hover' | 'always';
-export type EditorViewCommand = 'collapseRegion' | 'expandRegion' | 'collapseAllRegions' | 'expandAllRegions' | 'collapseRegionRecursively' | 'expandRegionRecursively' | 'foldSelection' | 'collapseDocComments' | 'expandDocComments' | 'expandAllToLevel1' | 'expandAllToLevel2' | 'expandAllToLevel3' | 'expandAllToLevel4' | 'expandAllToLevel5' | 'toggleColumnMode' | 'increaseFontSize' | 'decreaseFontSize' | 'resetFontSize';
+export type EditorViewCommand = 'collapseRegion' | 'expandRegion' | 'collapseAllRegions' | 'expandAllRegions' | 'collapseRegionRecursively' | 'expandRegionRecursively' | 'foldSelection' | 'collapseDocComments' | 'expandDocComments' | 'expandAllToLevel1' | 'expandAllToLevel2' | 'expandAllToLevel3' | 'expandAllToLevel4' | 'expandAllToLevel5' | 'toggleColumnMode' | 'increaseFontSize' | 'decreaseFontSize' | 'resetFontSize' | 'methodUp' | 'methodDown' | 'nextChange' | 'previousChange' | 'pasteAsPlainText';
 export interface EditorZoom {
     readonly min?: number;
     readonly max?: number;
@@ -139,6 +139,33 @@ export interface EditorContentChange {
     readonly range: EditorRange;
     readonly text: string;
 }
+export interface EditorTextPlace {
+    readonly language: string;
+    readonly kind: TextPlaceKind;
+}
+export interface EditorPostfixOperand {
+    readonly range: EditorRange;
+    readonly statement: boolean;
+}
+export interface EditorSurroundShape {
+    readonly range: EditorRange;
+    readonly statements: boolean;
+    readonly expression: boolean;
+}
+export interface EditorUnwrapTarget {
+    readonly kind: UnwrapKind;
+    readonly range: EditorRange;
+    readonly edits: readonly EditorContentChange[];
+}
+export interface EditorCopy {
+    readonly text: string;
+    readonly wholeLines: boolean;
+    readonly cut: boolean;
+}
+export interface EditorPasteOptions {
+    readonly wholeLines?: boolean;
+    readonly reindent?: boolean;
+}
 export interface EditorApplyEditsOptions {
     readonly mapSelections?: (range: EditorRange) => EditorRange;
     readonly mergeUndo?: boolean;
@@ -240,6 +267,7 @@ export interface EditorInlayHint {
     readonly parts?: readonly string[];
     readonly paddingLeft?: boolean;
     readonly paddingRight?: boolean;
+    readonly swatch?: string;
 }
 export interface EditorInlayTarget {
     readonly id: string;
@@ -336,6 +364,12 @@ export interface Editor {
     setTodoWords?(words: readonly string[]): void;
     setLabel(label: string): void;
     setFoldHints(hints: EditorFoldHints | null): void;
+    setDeclarations?(positions: readonly EditorPosition[] | null): void;
+    onNavigate?(listener: (from: EditorPosition) => void): () => void;
+    hasFocus?(): boolean;
+    setWordSources?(source: (() => readonly string[]) | null): void;
+    onCopy?(listener: (copy: EditorCopy) => void): () => void;
+    paste?(text: string, options?: EditorPasteOptions): boolean;
     setChangeMarks(marks: readonly EditorChangeMark[], layer?: string): void;
     setBlocks(blocks: readonly EditorBlock[] | null): void;
     onScope(listener: (scope: readonly EditorBlock[]) => void): () => void;
@@ -351,7 +385,7 @@ export interface Editor {
     setHighlights(highlights: readonly EditorHighlight[]): void;
     setLink(range: EditorRange | null): void;
     setSemanticTokens(tokens: readonly EditorSemanticToken[] | null): void;
-    setInlayHints(hints: readonly EditorInlayHint[]): void;
+    setInlayHints(hints: readonly EditorInlayHint[], owner?: string): void;
     onInlayHover?(listener: (target: EditorInlayTarget | null) => void): () => void;
     onInlayClick?(handler: EditorInlayClickHandler): () => void;
     setInlayLink?(target: {
@@ -404,6 +438,10 @@ export interface Editor {
     onFontSizeChange?(listener: (size: number | null) => void): () => void;
     setReadOnly(readOnly: boolean, reason?: string): void;
     isReadOnly?(): boolean;
+    placeAt?(position: EditorPosition): EditorTextPlace;
+    postfixOperands?(dot: EditorPosition): readonly EditorPostfixOperand[];
+    surroundShape?(range: EditorRange): EditorSurroundShape | null;
+    unwrapTargets?(position: EditorPosition): readonly EditorUnwrapTarget[];
     runCommand(command: EditorRunCommand): boolean;
     focus(): void;
     dispose(): void;

package/dist/view.d.ts

@@ -143,6 +143,7 @@ export declare class EditorView {
     private lenses;
     private readonly replacements;
     private occurrences;
+    private hippieSource;
     private replacePreview;
     private dropCaret;
     private activeGuideCache;
@@ -157,6 +158,7 @@ export declare class EditorView {
     private customFolds;
     private collapsed;
     private foldHints;
+    private declarations;
     private defaultRoles;
     private settled;
     private foldTimer;
@@ -188,6 +190,10 @@ export declare class EditorView {
     setLenses(lenses: readonly BlockWidget[]): void;
     private allBlocks;
     setOccurrences(occurrences: readonly Occurrence[]): void;
+    setHippieSource(range: {
+        from: number;
+        to: number;
+    } | null): void;
     setLink(link: {
         from: number;
         to: number;
@@ -239,6 +245,7 @@ export declare class EditorView {
     private foldStates;
     private scheduleFolds;
     refreshFolds(): void;
+    structureRanges(): FoldingRange[];
     private withCustomFolds;
     private closerOf;
     private foldAt;
@@ -274,6 +281,10 @@ export declare class EditorView {
             endLine: number;
         }[];
     } | null, defaults?: readonly FoldRole[]): void;
+    setDeclarations(offsets: readonly number[] | null): void;
+    private methodStops;
+    goToChange(direction: -1 | 1): boolean;
+    goToMethod(direction: -1 | 1): boolean;
     setFoldHints(hints: FoldHints | null): void;
     private applyFoldDefaults;
     foldRole(role: FoldRole, collapse: boolean): void;

package/dist/view.js

@@ -168,6 +168,7 @@ export class EditorView {
     lenses = [];
     replacements = new Map();
     occurrences = [];
+    hippieSource = null;
     replacePreview = null;
     dropCaret = null;
     activeGuideCache;
@@ -186,6 +187,7 @@ export class EditorView {
     collapsed = new Set();
     /* What a language server said about the folds, in offsets that follow the text through edits. */
     foldHints = null;
+    declarations = null;
     /* The roles that fold by themselves while the file is as it was opened; null once a person edited or the file opened with folds of its own. */
     defaultRoles = null;
     /* The folds somebody already decided on, a person or the defaults, so a later answer of a server leaves them as they are. */
@@ -427,6 +429,14 @@ export class EditorView {
         this.occurrences = [...occurrences];
         this.render();
     }
+    /* The word Hippie completion took from this document, shown until the next key or edit; null takes the mark away. */
+    setHippieSource(range) {
+        if (range === null && this.hippieSource === null) {
+            return;
+        }
+        this.hippieSource = range;
+        this.render();
+    }
     /* A name underlined as a link a press follows, with the pointer to match; null takes it away. */
     setLink(link) {
         this.link = link;
@@ -621,6 +631,7 @@ export class EditorView {
             this.markerVersion++;
             const anchor = this.topAnchor;
             this.occurrences = [];
+            this.hippieSource = null;
             this.link = null;
             this.content.classList.remove('se-content-link');
             this.outline.edited(batches);
@@ -668,6 +679,9 @@ export class EditorView {
         if (this.foldHints !== null) {
             this.foldHints = mapFoldHints(this.foldHints, map);
         }
+        if (this.declarations !== null) {
+            this.declarations = this.declarations.map((offset) => map(offset));
+        }
         this.customFolds = this.customFolds.map((fold) => mapRange(fold, map));
         this.find.mapBounds(changes);
         for (const [layer, marks] of this.changeLayers) {
@@ -801,20 +815,25 @@ export class EditorView {
         if (this.disposed || this.settings.folding === false) {
             return;
         }
-        const ranges = this.model.getLength() > FOLD_LIMIT
-            ? []
-            : this.model.getFoldingRanges({
-                indentation: /^(python|py|yaml|yml)$/.test(this.settings.language ?? ''),
-                tabSize: this.settings.tabSize,
-                ...(this.settings.language === undefined ? {} : { language: this.settings.language }),
-                ...(this.foldHints === null ? {} : { hints: this.foldHints })
-            });
+        const ranges = this.structureRanges();
         this.foldRanges = this.withCustomFolds(ranges);
         this.outline.setStructure(structuralEntries(ranges, this.model, (from, to) => this.model.slice(from, to), (offset) => this.model.matchBracket(offset, this.settings.language)?.mate));
         const anchors = new Set(this.foldRanges.map((range) => range.from));
         this.collapsed = new Set([...this.collapsed].filter((anchor) => anchors.has(anchor)));
         this.refoldLayout();
     }
+    /* The folding ranges the document has now, a server's included, whether or not the folds are drawn. */
+    structureRanges() {
+        if (this.model.getLength() > FOLD_LIMIT) {
+            return [];
+        }
+        return this.model.getFoldingRanges({
+            indentation: /^(python|py|yaml|yml)$/.test(this.settings.language ?? ''),
+            tabSize: this.settings.tabSize,
+            ...(this.settings.language === undefined ? {} : { language: this.settings.language }),
+            ...(this.foldHints === null ? {} : { hints: this.foldHints })
+        });
+    }
     /* The folds a person made of a selection, which the document's own structure does not know, among the ones it does. */
     withCustomFolds(ranges) {
         const custom = this.customFolds.flatMap((fold) => {
@@ -1023,6 +1042,49 @@ export class EditorView {
         this.applyFoldDefaults();
         this.refoldLayout();
     }
+    /* The places Method Up and Down stop at; they follow their text through edits until set again, and null goes back to the editor's own reading. */
+    setDeclarations(offsets) {
+        this.declarations = offsets === null ? null : [...new Set(offsets)].sort((left, right) => left - right);
+    }
+    methodStops() {
+        if (this.declarations !== null) {
+            return this.declarations;
+        }
+        const sections = this.foldRanges.filter((range) => range.kind === 'section').map((range) => this.model.getLine(range.startLine).start);
+        return [...new Set([...this.outline.declarationStops(this.model), ...sections])].sort((left, right) => left - right);
+    }
+    /* Moves the one caret to the first line of the next or previous change mark, of any layer. False when there is none. */
+    goToChange(direction) {
+        const line = this.model.positionAt(this.model.getPrimary().head).line;
+        const { runs } = this.resolvedChanges();
+        // A run the caret is in is where it already is; a deleted run is the line its mark sits on.
+        const target = direction === 1 ? runs.find((run) => run.start > line) : runs.findLast((run) => (run.kind === 'deleted' ? run.start : run.end) < line);
+        if (target === undefined) {
+            return false;
+        }
+        const offset = this.model.getLine(Math.min(target.start, this.model.getLineCount() - 1)).start;
+        this.model.setSelections([{ anchor: offset, head: offset }]);
+        this.revealOffset(offset, 'center');
+        return true;
+    }
+    /* Moves the one caret to the previous or next declaration on another line. False when there is none. */
+    goToMethod(direction) {
+        // The structure is read after a pause in typing, so a press right after an edit reads it now.
+        if (this.declarations === null) {
+            this.refreshFolds();
+        }
+        const line = this.model.positionAt(this.model.getPrimary().head).line;
+        const stops = this.methodStops();
+        const target = direction === 1
+            ? stops.find((offset) => this.model.positionAt(offset).line > line)
+            : stops.findLast((offset) => this.model.positionAt(offset).line < line);
+        if (target === undefined) {
+            return false;
+        }
+        this.model.setSelections([{ anchor: target, head: target }]);
+        this.revealOffset(target, direction === 1 ? 'centerDown' : 'centerUp');
+        return true;
+    }
     /* Hands over what a language server knows about the folds; null forgets it. The defaults fold what the answer names, once. */
     setFoldHints(hints) {
         this.foldHints = hints;
@@ -1866,6 +1928,9 @@ export class EditorView {
                 });
             }
         }
+        if (this.hippieSource !== null) {
+            marks.push({ className: 'se-hippie-source', rects: this.paintRectangles(this.hippieSource.from, this.hippieSource.to, rows) });
+        }
         const marginX = this.settings.rightMargin === null ? null : this.settings.rightMargin * this.layout.metrics.charWidth;
         // A margin past the content would stretch the scroll extent to itself, so it shows only where the text or the view reaches it.
         if (marginX !== null && marginX < Math.max(this.layout.width, this.viewportWidth)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "type": "module",
   "exports": {
     ".": {
@@ -54,7 +54,7 @@
     "test": "bun test --conditions=source"
   },
   "dependencies": {
-    "@adecore/editor-core": "0.42.0",
+    "@adecore/editor-core": "0.44.0",
     "linkedom": "^0.18.14",
     "shiki": "^4.5.0"
   },