@adecore/editor 0.42.0 → 0.43.0

package/src/engine.ts

@@ -17,6 +17,7 @@ import type {
     EditorCodeVision,
     EditorClickHandler,
     EditorContextMenu,
+    EditorCopy,
     EditorContentChange,
     EditorEngine,
     EditorFindQuery,
@@ -36,6 +37,7 @@ import type {
     EditorInlayHint,
     EditorInlayTarget,
     EditorKeyHandler,
+    EditorPasteOptions,
     EditorInputPopup,
     EditorMarker,
     EditorMessages,
@@ -90,6 +92,8 @@ class SmartEditor implements Editor {
     private lensRevisions = new Map<string, { signature: string; revision: number }>();
     private tokenizerRequest = 0;
     private settingText = false;
+    /* The hints of each owner, in the order the owners first set theirs. */
+    private readonly inlayOwners = new Map<string, readonly EditorInlayHint[]>();
     private disposed = false;
 
     private readonly engine: SmartEditorEngineOptions;
@@ -429,15 +433,21 @@ class SmartEditor implements Editor {
         );
     }
 
-    setInlayHints(hints: readonly EditorInlayHint[]): void {
+    setInlayHints(hints: readonly EditorInlayHint[], owner: string = DEFAULT_WIDGET_OWNER): void {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        } else {
+            this.inlayOwners.set(owner, hints);
+        }
         this.view.setInlays(
-            hints.map((hint, index) => ({
+            [...this.inlayOwners.values()].flat().map((hint, index) => ({
                 id: hint.id ?? `hint-${index}`,
                 at: this.offsetAt(hint.position),
                 text: hint.label,
                 ...(hint.parts === undefined ? {} : { parts: hint.parts }),
                 ...(hint.paddingLeft ? { gapLeft: INLAY_GAP } : {}),
-                ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {})
+                ...(hint.paddingRight ? { gapRight: INLAY_GAP } : {}),
+                ...(hint.swatch === undefined ? {} : { swatch: hint.swatch })
             }))
         );
     }
@@ -938,6 +948,30 @@ class SmartEditor implements Editor {
         this.view.setFoldHints(hints === null ? null : this.foldHintsByOffset(hints));
     }
 
+    setDeclarations(positions: readonly EditorPosition[] | null): void {
+        this.view.setDeclarations(positions === null ? null : positions.map((position) => this.offsetAt(position)));
+    }
+
+    onNavigate(listener: (from: EditorPosition) => void): () => void {
+        return this.controller.onNavigate((from) => listener(this.positionAt(from)));
+    }
+
+    hasFocus(): boolean {
+        return this.view.focused;
+    }
+
+    setWordSources(source: (() => readonly string[]) | null): void {
+        this.controller.setWordSources(source);
+    }
+
+    onCopy(listener: (copy: EditorCopy) => void): () => void {
+        return this.controller.onCopy(listener);
+    }
+
+    paste(text: string, options?: EditorPasteOptions): boolean {
+        return this.controller.pasteText(text, options);
+    }
+
     private foldHintsByOffset(hints: EditorFoldHints): FoldHints {
         const lineOf = (line: number): { start: number; end: number } => this.model.getLine(Math.min(line, this.model.getLineCount() - 1));
 

package/src/fake.ts

@@ -46,6 +46,8 @@ import type {
     EditorSemanticToken,
     EditorSmartKeys,
     EditorApplyEditsOptions,
+    EditorCopy,
+    EditorPasteOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorTheme,
@@ -823,6 +825,78 @@ export class FakeEditor implements Editor {
         this.foldHints = hints;
     }
 
+    declarations: readonly EditorPosition[] | null = null;
+
+    setDeclarations(positions: readonly EditorPosition[] | null): void {
+        this.declarations = positions;
+    }
+
+    private readonly navigations = new Set<(from: EditorPosition) => void>();
+
+    onNavigate(listener: (from: EditorPosition) => void): () => void {
+        return subscribe(this.navigations, listener);
+    }
+
+    /* Stands for a command that navigated: tells the listeners the caret left `from`. */
+    navigate(from: EditorPosition): void {
+        emit(this.navigations, from);
+    }
+
+    hasFocus(): boolean {
+        return this.focused;
+    }
+
+    private readonly copies = new Set<(copy: EditorCopy) => void>();
+
+    onCopy(listener: (copy: EditorCopy) => void): () => void {
+        return subscribe(this.copies, listener);
+    }
+
+    /* Stands for a copy or cut of a person: tells the listeners what went on the clipboard. */
+    copy(text: string, wholeLines = false, cut = false): void {
+        emit(this.copies, { text, wholeLines, cut });
+    }
+
+    /* Every paste a host asked for, with its options. */
+    readonly pastes: Array<{ text: string; options: EditorPasteOptions | undefined }> = [];
+
+    /* Puts the text at every caret, one line per caret when the lines are as many as the carets, and leaves the carets behind it. */
+    paste(text: string, options?: EditorPasteOptions): boolean {
+        this.assertLive();
+        this.pastes.push({ text, options });
+
+        if (this.readOnly || text === '') {
+            return false;
+        }
+
+        const lines = text.split('\n');
+        const selections = [...this.selections].sort((left, right) => Math.min(left.anchor, left.head) - Math.min(right.anchor, right.head));
+        const perCaret = lines.length === selections.length;
+
+        const edits = selections.map((selection, index) => ({
+            from: Math.min(selection.anchor, selection.head),
+            to: Math.max(selection.anchor, selection.head),
+            text: perCaret ? lines[index]! : text
+        }));
+
+        return this.edit(edits, 'command', false, () => {
+            let shift = 0;
+
+            return edits.map((edit) => {
+                const caret = edit.from + shift + edit.text.length;
+                shift += edit.text.length - (edit.to - edit.from);
+
+                return { anchor: caret, head: caret };
+            });
+        });
+    }
+
+    wordSources: (() => readonly string[]) | null = null;
+
+    setWordSources(source: (() => readonly string[]) | null): void {
+        this.wordSources = source;
+    }
+
     setSmartKeys(keys: Partial<EditorSmartKeys>): void {
         this.smartKeys = keys;
     }
@@ -847,11 +921,17 @@ export class FakeEditor implements Editor {
         this.markers = markers;
     }
 
-    /* What the host drew as hints last. */
+    /* What the host drew as hints last, every owner's together. */
     inlayHints: readonly EditorInlayHint[] = [];
+    private readonly inlayOwners = new Map<string, readonly EditorInlayHint[]>();
 
-    setInlayHints(hints: readonly EditorInlayHint[]): void {
-        this.inlayHints = hints;
+    setInlayHints(hints: readonly EditorInlayHint[], owner = 'default'): void {
+        if (hints.length === 0) {
+            this.inlayOwners.delete(owner);
+        } else {
+            this.inlayOwners.set(owner, hints);
+        }
+        this.inlayHints = [...this.inlayOwners.values()].flat();
     }
 
     private readonly inlayHovers = new Set<(target: EditorInlayTarget | null) => void>();
@@ -1208,6 +1288,8 @@ export class FakeEditor implements Editor {
         this.changes.clear();
         this.textChanges.clear();
         this.carets.clear();
+        this.navigations.clear();
+        this.copies.clear();
         this.hovers.clear();
         this.inlayHovers.clear();
         this.inlayHandlers.clear();

package/src/index.ts

@@ -4,6 +4,7 @@ export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from '@adecore/edi
 export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from '@adecore/editor-core';
 export { detectIndentation, type DetectedIndentation } from '@adecore/editor-core';
 export { createSmartEditorEngine } from './engine.ts';
+export { rememberCopy } from './controller.ts';
 export { DEFAULT_SMART_KEYS } from './smart-keys.ts';
 export { shikiScopeColors, shikiTokenizers } from './shiki.ts';
 
@@ -61,6 +62,8 @@ export type {
     EditorRemoteCursor,
     EditorRange,
     EditorApplyEditsOptions,
+    EditorCopy,
+    EditorPasteOptions,
     EditorTextChange,
     EditorTrackedRange,
     EditorRunCommand,

package/src/keymap-table.ts

@@ -33,10 +33,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'),
@@ -49,8 +54,21 @@ export const KEYMAP = {
     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'),
@@ -72,9 +90,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+='),
@@ -104,6 +123,7 @@ export const KEYMAP = {
     renameSymbol: bind('Shift+F6'),
     organizeImports: bind('Ctrl+Alt+O'),
     formatDocument: bind('Mod+Alt+L'),
+    wrapWithAbbreviation: bind('Mod+Alt+J'),
     selectionToChat: bind(null),
     inlineEdit: bind(null),
     suggestInline: bind(null),
@@ -116,6 +136,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'),
@@ -142,7 +163,26 @@ export type OptionalKeymapId =
     | 'reverseLines'
     | 'uniqueLines'
     | 'convertIndentsToSpaces'
-    | 'convertIndentsToTabs';
+    | 'convertIndentsToTabs'
+    | 'completeCurrentStatement'
+    | 'hippieCompletion'
+    | 'hippieBackwardCompletion'
+    | 'moveStatementUp'
+    | 'moveStatementDown'
+    | 'lastEditLocation'
+    | 'nextEditLocation'
+    | 'methodUp'
+    | 'methodDown'
+    | 'pasteFromHistory'
+    | 'pasteAsPlainText'
+    | 'nextChange'
+    | 'previousChange'
+    | 'codeBlockStart'
+    | 'codeBlockEnd'
+    | 'codeBlockStartWithSelection'
+    | 'codeBlockEndWithSelection'
+    | 'wrapWithAbbreviation'
+    | 'typeHierarchy';
 
 export type Keymap = Readonly<Record<Exclude<KeymapId, OptionalKeymapId>, KeyBinding> & Partial<Record<OptionalKeymapId, KeyBinding>>>;
 export type KeymapOverrides = Partial<Record<KeymapId, Partial<KeyBinding>>>;

package/src/keymap.ts

@@ -44,10 +44,15 @@ const ACTIONS: Partial<Record<KeymapId, KeyAction>> = {
     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'),
@@ -60,6 +65,15 @@ const ACTIONS: Partial<Record<KeymapId, KeyAction>> = {
     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/src/layout.ts

@@ -57,8 +57,13 @@ export interface Inlay {
     composition?: boolean;
     /* A suggestion the host drew after the caret: text in the code face with no padding, which the caret stays in front of. */
     ghost?: boolean;
+    /* A square of this CSS color in place of the text, such as the color a literal in the code stands for. */
+    swatch?: string;
 }
 
+/* The side of a swatch in pixels, without its gaps. */
+export const SWATCH_SIZE = 12;
+
 /* A row of the host's own DOM above or below a line, as tall as the host makes it. */
 export interface BlockWidget {
     id: string;
@@ -366,10 +371,13 @@ export function scanDenseLine(
             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/src/outline.ts

@@ -215,6 +215,19 @@ export class Outline {
         this.version++;
     }
 
+    /* Where the named blocks of the structure declare their name, in no order: the stops of Method Up and Down. */
+    declarationStops(document: OutlineDocument): number[] {
+        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: OutlineDocument): readonly OutlineBlock[] {
         if (this.cache?.version !== this.version) {

package/src/paint.ts

@@ -186,11 +186,20 @@ export function lineElement(
         }
 
         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 {
             parts.forEach((part, index) => {

package/src/types.ts

@@ -28,7 +28,12 @@ export type EditorViewCommand =
     | 'toggleColumnMode'
     | 'increaseFontSize'
     | 'decreaseFontSize'
-    | 'resetFontSize';
+    | 'resetFontSize'
+    | 'methodUp'
+    | 'methodDown'
+    | 'nextChange'
+    | 'previousChange'
+    | 'pasteAsPlainText';
 
 /* How far a person may zoom the text, and whether the wheel does. */
 export interface EditorZoom {
@@ -283,6 +288,21 @@ export interface EditorContentChange {
     readonly text: string;
 }
 
+/* What a copy or cut put on the clipboard. */
+export interface EditorCopy {
+    readonly text: string;
+    /* A copy of bare carets takes their lines, which paste back above the lines of bare carets. */
+    readonly wholeLines: boolean;
+    readonly cut: boolean;
+}
+
+export interface EditorPasteOptions {
+    /* Pastes above the lines of bare carets, as the paste of a copy of bare carets does; by default when the text is the last such copy. */
+    readonly wholeLines?: boolean;
+    /* False leaves the indentation of the text alone; the editor's indent on paste setting otherwise. */
+    readonly reindent?: boolean;
+}
+
 export interface EditorApplyEditsOptions {
     readonly mapSelections?: (range: EditorRange) => EditorRange;
     readonly mergeUndo?: boolean;
@@ -472,6 +492,8 @@ export interface EditorInlayHint {
     /* 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 square of this CSS color in place of the label, such as the color a literal stands for; the label is then what assistive technology reads. */
+    readonly swatch?: string;
 }
 
 /* A hint, or one part of its label, under the pointer. */
@@ -649,6 +671,18 @@ 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;
+    /* The places Method Up and Down stop at, such as the names of a language server's symbols. They follow their text through edits until set again; null goes back to the editor's own reading of the structure. Optional so an editor from before it still fits. */
+    setDeclarations?(positions: readonly EditorPosition[] | null): void;
+    /* A command that navigates (Method Up and Down, Code Block Start and End) moved the primary caret away from `from`. Optional so an editor from before it still fits. */
+    onNavigate?(listener: (from: EditorPosition) => void): () => void;
+    /* Whether the editor has the keyboard focus. Optional so an editor from before it still fits. */
+    hasFocus?(): boolean;
+    /* The texts of the other open documents, which Hippie completion takes words from after those of this one; null takes them away. Optional so an editor from before it still fits. */
+    setWordSources?(source: (() => readonly string[]) | null): void;
+    /* Told after a copy or cut, with the text it put on the clipboard. Optional so an editor from before it still fits. */
+    onCopy?(listener: (copy: EditorCopy) => void): () => void;
+    /* Pastes `text` as a paste from the clipboard does: at every caret, with indent on paste, and refused with its notice when the editor is read-only. False when nothing was pasted. Optional so an editor from before it still fits. */
+    paste?(text: string, options?: EditorPasteOptions): boolean;
     /*
      * 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
@@ -699,7 +733,8 @@ export interface Editor {
     /* Colors by what the language servers know, over what the grammar made of the text; null takes them away. */
     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;
+    /* Each owner sets its own hints and keeps those of the others; ids stay unique across owners. */
+    setInlayHints(hints: readonly EditorInlayHint[], owner?: string): 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. */

package/src/view.ts

@@ -298,6 +298,7 @@ export class EditorView {
     private lenses: BlockWidget[] = [];
     private readonly replacements = new Map<string, BlockReplacement[]>();
     private occurrences: Occurrence[] = [];
+    private hippieSource: { from: number; to: number } | null = null;
     private replacePreview: { text: string; preserveCase: boolean } | null = null;
     private dropCaret: number | null = null;
     private activeGuideCache: { key: string; guide: { column: number; first: number; last: number } | null } | undefined;
@@ -316,6 +317,7 @@ export class EditorView {
     private collapsed = new Set<number>();
     /* What a language server said about the folds, in offsets that follow the text through edits. */
     private foldHints: FoldHints | null = null;
+    private declarations: number[] | null = 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. */
     private defaultRoles: ReadonlySet<FoldRole> | null = null;
     /* The folds somebody already decided on, a person or the defaults, so a later answer of a server leaves them as they are. */
@@ -600,6 +602,16 @@ export class EditorView {
         this.render();
     }
 
+    /* The word Hippie completion took from this document, shown until the next key or edit; null takes the mark away. */
+    setHippieSource(range: { from: number; to: number } | null): void {
+        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: { from: number; to: number } | null): void {
         this.link = link;
@@ -849,6 +861,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);
@@ -916,6 +929,10 @@ export class EditorView {
             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);
 
@@ -1089,15 +1106,7 @@ export class EditorView {
             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);
 
@@ -1115,6 +1124,20 @@ export class EditorView {
         this.refoldLayout();
     }
 
+    /* The folding ranges the document has now, a server's included, whether or not the folds are drawn. */
+    structureRanges(): FoldingRange[] {
+        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. */
     private withCustomFolds(ranges: readonly FoldingRange[]): ViewFold[] {
         const custom = this.customFolds.flatMap((fold): ViewFold[] => {
@@ -1383,6 +1406,65 @@ export class EditorView {
         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: readonly number[] | null): void {
+        this.declarations = offsets === null ? null : [...new Set(offsets)].sort((left, right) => left - right);
+    }
+
+    private methodStops(): number[] {
+        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: -1 | 1): boolean {
+        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: -1 | 1): boolean {
+        // 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: FoldHints | null): void {
         this.foldHints = hints;
@@ -2480,6 +2562,10 @@ 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.