@adecore/editor-core 0.42.0 → 0.43.0

package/dist/code-blocks.d.ts

@@ -0,0 +1,8 @@
+import type { EditSource } from './edit-source.ts';
+import type { Selection } from './types.ts';
+export interface CodeBlockOptions {
+    tabSize: number;
+    guides: boolean;
+    mate(offset: number): number | undefined;
+}
+export declare function planCodeBlock(source: EditSource, selections: readonly Selection[], edge: 'start' | 'end', extend: boolean, options: CodeBlockOptions): Selection[];

package/dist/code-blocks.js

@@ -0,0 +1,59 @@
+import { isBlank, textStart } from './line-text.js';
+import { enclosingBraces, indentGuideAt, visualWidth } from './statements.js';
+function guideTarget(source, head, edge, options) {
+    const line = source.lineAt(head);
+    const info = source.line(line);
+    const column = visualWidth(info.text.slice(0, head - info.start), options.tabSize);
+    const guide = indentGuideAt(source, line, column, options.tabSize);
+    if (guide === null) {
+        return null;
+    }
+    if (edge === 'start') {
+        return guide.startLine === line ? null : textStart(source.line(guide.startLine));
+    }
+    if (guide.endLine >= source.lineCount) {
+        return source.line(source.lineCount - 1).end;
+    }
+    const last = source.line(guide.endLine);
+    return isBlank(last.text) ? last.end : textStart(last);
+}
+function braceTarget(source, head, edge, options) {
+    if (edge === 'end') {
+        if (source.charAt(head) === '{') {
+            const mate = options.mate(head);
+            if (mate !== undefined && mate > head) {
+                return mate + 1;
+            }
+        }
+        for (const brace of enclosingBraces(source, head)) {
+            const mate = options.mate(brace);
+            // A caret already in front of the closer goes on to the block around it.
+            if (mate !== undefined && mate > head) {
+                return mate;
+            }
+        }
+        return null;
+    }
+    if (head > 0 && source.charAt(head - 1) === '}') {
+        const mate = options.mate(head - 1);
+        if (mate !== undefined && mate < head) {
+            return mate;
+        }
+    }
+    for (const brace of enclosingBraces(source, head)) {
+        if (brace + 1 < head) {
+            return brace + 1;
+        }
+    }
+    return null;
+}
+/* Where each caret goes for Code Block Start or End; a caret with no block around it stays. The selection extends from its anchor when `extend` is set. */
+export function planCodeBlock(source, selections, edge, extend, options) {
+    return selections.map((selection) => {
+        const target = (options.guides ? guideTarget(source, selection.head, edge, options) : null) ?? braceTarget(source, selection.head, edge, options);
+        if (target === null) {
+            return selection;
+        }
+        return { anchor: extend ? selection.anchor : target, head: target };
+    });
+}

package/dist/complete-statement.d.ts

@@ -0,0 +1,8 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection } from './types.ts';
+export interface CompleteStatementOptions {
+    language: string;
+    unit: string;
+    tabSize: number;
+}
+export declare function planCompleteStatement(source: EditSource, selections: readonly Selection[], options: CompleteStatementOptions): EditPlan;

package/dist/complete-statement.js

@@ -0,0 +1,157 @@
+import { continues, planEnter } from './enter.js';
+import { isBraced, statementTerminator } from './lexical.js';
+import { whitespaceOf } from './line-text.js';
+import { BODIES, DECLARATION, declarationBody, METHOD, NOT_METHODS, statementStart } from './statements.js';
+const CONTROL = /^(?:else\s+if|elseif|if|for|foreach|while|switch|catch|with)\b/;
+const PYTHON_BLOCK = /^(?:async\s+)?(?:if|elif|else|for|while|def|class|try|except|finally|with|match|case)\b/;
+function startNewLine(source, line, options) {
+    const end = source.line(line).end;
+    return planEnter(source, end, end, { ...options, smart: true, reach: false });
+}
+/* The offset a statement on this line ends at: before a trailing comment and the whitespace in front of it. Null where the line is not code. */
+function statementEnd(source, line, caret) {
+    const info = source.line(line);
+    if (/comment/.test(source.context(caret).mode)) {
+        return null;
+    }
+    const atEnd = source.context(info.end);
+    let end = info.end;
+    if (atEnd.mode === 'line-comment' && atEnd.commentStart !== undefined) {
+        end = atEnd.commentStart;
+    }
+    while (end > info.start && /\s/.test(source.charAt(end - 1))) {
+        end--;
+    }
+    if (end === info.start) {
+        return null;
+    }
+    const mode = source.context(end).mode;
+    return mode === 'code' || mode === 'quote' ? end : null;
+}
+/* The parenthesis of a control statement closes at the end of the text: `if (a)`, and no body after it. */
+function endsWithCondition(head) {
+    const open = head.indexOf('(');
+    if (open < 0) {
+        return false;
+    }
+    let depth = 0;
+    for (let i = open; i < head.length; i++) {
+        depth += head[i] === '(' ? 1 : head[i] === ')' ? -1 : 0;
+        if (depth === 0) {
+            return i === head.length - 1;
+        }
+    }
+    return false;
+}
+function completeBraced(source, lineIndex, caret, options) {
+    const line = source.line(lineIndex);
+    const end = statementEnd(source, lineIndex, caret);
+    if (end === null || (source.region(lineIndex) ?? 'script') !== 'script') {
+        return startNewLine(source, lineIndex, options);
+    }
+    const context = source.context(end);
+    const first = statementStart(source, lineIndex, options.language);
+    const firstStart = source.line(first).start;
+    const startsWithBrace = /^\s*\}/.test(line.text);
+    let inline = context.mode === 'quote' ? (context.quote ?? '') : '';
+    let open = context.bracket;
+    for (; open !== undefined && open.template !== true && !(open.close === '}' && open.block === true) && open.at >= firstStart; open = open.previous) {
+        inline += open.close;
+    }
+    const tail = source.slice(end, line.end);
+    const newline = source.newline(lineIndex);
+    const indent = whitespaceOf(startsWithBrace ? line.text : source.line(first).text);
+    const body = indent + options.unit;
+    const written = (startsWithBrace ? source.slice(line.start, end) : source.slice(firstStart, end)) + inline;
+    const head = (startsWithBrace ? written.trim().slice(1) : written).trim();
+    const nothing = () => startNewLine(source, lineIndex, options);
+    const replaceTail = (text, caretAt) => ({ from: end, to: line.end, text, caret: caretAt });
+    // A block with its closer on a line of its own and the caret on the line between.
+    const block = (opener, closer = '}') => {
+        const opened = `${inline}${opener}${tail}${newline}${body}`;
+        return replaceTail(`${opened}${newline}${indent}${closer}`, opened.length);
+    };
+    if (inline === '' && head.endsWith('{}') && source.context(end - 1).bracket?.block === true) {
+        return { from: end - 1, to: line.end, text: `${newline}${body}${newline}${indent}}${tail}`, caret: newline.length + body.length };
+    }
+    if (inline === '' && head.endsWith('{')) {
+        if (tail === '') {
+            return startNewLine(source, lineIndex, options);
+        }
+        const opened = `${tail}${newline}${body}`;
+        return replaceTail(source.unclosedBrace(end - 1) ? `${opened}${newline}${indent}}` : opened, opened.length);
+    }
+    const control = CONTROL.exec(head);
+    const condition = control === null ? null : head.slice(control[0].length).trim();
+    if (control !== null && condition === '') {
+        return replaceTail(`${inline} () {${tail}${newline}${indent}}`, inline.length + 2);
+    }
+    if (control !== null && !(control[0] === 'while' && startsWithBrace) && condition.startsWith('(') && endsWithCondition(condition)) {
+        return block(' {');
+    }
+    if (/^(?:else|try|finally|do)$/.test(head)) {
+        return block(' {', head === 'do' ? '} while ();' : '}');
+    }
+    if ((/^case\b/.test(head) && head.length > 4 && !head.endsWith(':')) || head === 'default') {
+        const text = `${inline}:${tail}${newline}${body}`;
+        return replaceTail(text, text.length);
+    }
+    const declaring = declarationBody(source, end);
+    const declaration = DECLARATION.exec(head)?.[1];
+    const method = declaration === undefined && declaring === 'other' ? METHOD.exec(head)?.[1] : undefined;
+    if (declaring !== 'interface' && (declaration !== undefined || (method !== undefined && !NOT_METHODS.has(method)))) {
+        const bodiless = /^(?:\w+\s+)*?(?:abstract|declare)\s/.test(head) && !BODIES.has(declaration ?? '');
+        if (!bodiless) {
+            return block(' {');
+        }
+    }
+    const terminator = statementTerminator(options.language);
+    const last = head.at(-1);
+    const closedBlock = inline === '' && last === '}' && source.context(end - 1).bracket?.block === true;
+    const inExpression = open !== undefined && !(open.close === '}' && open.block === true);
+    const goesOn = inline === '' && continues(source.slice(line.start, end), context, options.language);
+    const ends = terminator !== null && head !== '' && !/^(?:@|#\[)/.test(head) && !';{,:'.includes(last) && !closedBlock && !inExpression && !goesOn;
+    const added = inline + (ends ? terminator : '');
+    return added === '' ? nothing() : { from: end, to: end, text: added, caret: added.length };
+}
+function completePython(source, lineIndex, caret, options) {
+    const line = source.line(lineIndex);
+    const end = statementEnd(source, lineIndex, caret);
+    if (end === null || source.context(end).mode !== 'code') {
+        return startNewLine(source, lineIndex, options);
+    }
+    let inline = '';
+    for (let open = source.context(end).bracket; open !== undefined; open = open.previous) {
+        inline += open.close;
+    }
+    const head = (source.slice(line.start, end) + inline).trim();
+    const tail = source.slice(end, line.end);
+    if (PYTHON_BLOCK.test(head) && !head.endsWith(':')) {
+        const text = `${inline}:${tail}${source.newline(lineIndex)}${whitespaceOf(line.text)}${options.unit}`;
+        return { from: end, to: line.end, text, caret: text.length };
+    }
+    return inline === '' ? startNewLine(source, lineIndex, options) : { from: end, to: end, text: inline, caret: inline.length };
+}
+/* Where Complete Current Statement puts its edits for the carets. Every caret acts on its line, and carets on one line count once. */
+export function planCompleteStatement(source, selections, options) {
+    const complete = isBraced(options.language) ? completeBraced : /^(python|py)$/i.test(options.language) ? completePython : null;
+    const pieces = new Map();
+    for (const selection of selections) {
+        const line = source.lineAt(selection.head);
+        pieces.set(line, complete === null ? startNewLine(source, line, options) : complete(source, line, selection.head, options));
+    }
+    const ordered = [...pieces.entries()].sort((left, right) => left[1].from - right[1].from);
+    const carets = new Map();
+    let delta = 0;
+    for (const [line, piece] of ordered) {
+        carets.set(line, piece.from + delta + piece.caret);
+        delta += piece.text.length - (piece.to - piece.from);
+    }
+    return {
+        edits: ordered.map(([, piece]) => ({ from: piece.from, to: piece.to, text: piece.text })),
+        selections: selections.map((selection) => {
+            const caret = carets.get(source.lineAt(selection.head));
+            return { anchor: caret, head: caret };
+        })
+    };
+}

package/dist/document.d.ts

@@ -49,6 +49,11 @@ export declare class DocumentModel {
     private cloneSession;
     private occurrenceSession;
     occurrencesExhausted: boolean;
+    hippieSource: {
+        from: number;
+        to: number;
+    } | null;
+    private hippieState;
     private closers;
     private bracketCache?;
     private bracketTracker;
@@ -124,6 +129,8 @@ export declare class DocumentModel {
     private touchedLines;
     private duplicate;
     private deleteLines;
+    private moveStatements;
+    private completeFromWords;
     private moveLines;
     private insertNewline;
     private startNewLineBefore;

package/dist/document.js

@@ -2,6 +2,10 @@ import { scriptSource } from './script-source.js';
 import { CloserTracker } from './closer-tracker.js';
 import { planBlockComment, planLineComments } from './comments.js';
 import { planEnter } from './enter.js';
+import { planCodeBlock } from './code-blocks.js';
+import { planCompleteStatement } from './complete-statement.js';
+import { planMoveStatement, statementMoveMode } from './statement-move.js';
+import { planHippie } from './hippie.js';
 import { planAutoIndent, planJoinLines, planToggleCase, properIndent, spacingBetween } from './line-commands.js';
 import { mapOffset, offsetMapper } from './offsets.js';
 import { planPaste } from './paste.js';
@@ -39,6 +43,7 @@ const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
 /* What can follow `->`: the first letter of a member name, or the `{` of a dynamic one. */
 const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
+const codeBlockCommand = /^codeBlock(Start|End)(WithSelection)?$/;
 let graphemes;
 function sameSelections(left, right) {
     return left.length === right.length && left.every((selection, index) => selection.anchor === right[index].anchor && selection.head === right[index].head);
@@ -277,6 +282,9 @@ export class DocumentModel {
     occurrenceSession;
     /* The last select next occurrence found no more, which a host may say. */
     occurrencesExhausted = false;
+    /* Where the word the last Hippie completion took from this document stands, which a view reads right after the command to show it. */
+    hippieSource = null;
+    hippieState = null;
     closers = new CloserTracker();
     bracketCache;
     bracketTracker = new BracketTracker(() => this.rope);
@@ -703,6 +711,25 @@ export class DocumentModel {
             const pairing = options.autoClosingPairs !== false && !isPlainText(language);
             return this.deleteCharacter(command === 'smartBackspace', { tabSize, unit }, { brackets: pairing && options.autoClosingBrackets !== false, quotes: pairing && options.autoClosingQuotes !== false }, language);
         }
+        if (command === 'moveStatementUp' || command === 'moveStatementDown') {
+            return this.moveStatements(command === 'moveStatementUp' ? -1 : 1, { language, unit, tabSize }, options);
+        }
+        if (command === 'hippieCompletion' || command === 'hippieBackwardCompletion') {
+            return this.completeFromWords(command === 'hippieCompletion' ? 1 : -1, { language, wordSources: options.wordSources });
+        }
+        if (command === 'completeCurrentStatement') {
+            const plan = planCompleteStatement(this.editSource(language), this.selections, { language, unit, tabSize });
+            return this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+        }
+        const blockMatch = codeBlockCommand.exec(command);
+        if (blockMatch) {
+            const plan = planCodeBlock(this.editSource(language), this.selections, blockMatch[1] === 'Start' ? 'start' : 'end', blockMatch[2] !== undefined, {
+                tabSize,
+                guides: options.indentGuides === true,
+                mate: (offset) => this.matchBracket(offset, language)?.mate
+            });
+            return this.changeSelections(plan);
+        }
         const enter = { language, unit, tabSize, smart: options.smartEnter !== false, reach: true };
         if (command === 'insertNewline' || command === 'startNewLine' || command === 'splitLine') {
             return this.insertNewline(enter, command === 'insertNewline' ? 'enter' : command === 'startNewLine' ? 'below' : 'split');
@@ -1334,6 +1361,47 @@ export class DocumentModel {
         }
         return this.applyEdits(edits, { source: 'command', selections });
     }
+    /* Moves the statement at each caret past its neighbor; a language without brackets or indentation to go by moves lines. */
+    moveStatements(direction, settings, options) {
+        if (statementMoveMode(settings.language) === null) {
+            return this.moveLines(this.selectedLines(options.lineSpan), direction, options);
+        }
+        const structure = options.structure?.() ?? this.getFoldingRanges({ language: settings.language, tabSize: settings.tabSize });
+        const plan = planMoveStatement(this.editSource(settings.language), this.selections, direction, { ...settings, structure, lineSpan: options.lineSpan });
+        if (plan === null) {
+            return false;
+        }
+        const changed = this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+        if (changed) {
+            options.onLinesMoved?.(plan.moves);
+        }
+        return changed;
+    }
+    /* Hippie completion: the word before every caret becomes the next longer word that starts the same, from this document and then from the others. */
+    completeFromWords(direction, options) {
+        const carets = this.selections.map((selection) => selection.head).sort((a, b) => a - b);
+        const primary = this.selections.at(-1).head;
+        const held = this.hippieState;
+        const continues = held !== null &&
+            held.revision === this.revision &&
+            held.cycle.carets.length === carets.length &&
+            held.cycle.carets.every((caret, i) => caret === carets[i]);
+        const plan = planHippie(this.getText(), carets, primary, continues ? held.cycle : null, direction, options);
+        this.hippieState = null;
+        this.hippieSource = null;
+        if (plan === null) {
+            return false;
+        }
+        const primaryIndex = carets.indexOf(primary);
+        const landed = plan.carets.map((caret) => ({ anchor: caret, head: caret }));
+        const [primaryCaret] = landed.splice(primaryIndex, 1);
+        this.applyEdits(plan.edits, { source: 'command', selections: [...landed, primaryCaret] });
+        if (plan.cycle !== null) {
+            this.hippieState = { cycle: plan.cycle, revision: this.revision };
+            this.hippieSource = plan.source;
+        }
+        return true;
+    }
     moveLines(indices, direction, options) {
         const span = options.lineSpan ?? ((line) => ({ first: line, last: line }));
         const groups = blocks(indices).filter((block) => (direction === -1 ? block.first > 0 : block.last < this.getLineCount() - 1));

package/dist/hippie.d.ts

@@ -0,0 +1,34 @@
+import type { TextEdit } from './types.ts';
+export interface HippieOptions {
+    language: string;
+    wordSources?: () => readonly string[];
+}
+interface Word {
+    text: string;
+    start: number;
+    end: number;
+}
+interface Variant extends Word {
+    source: 'here' | 'other';
+    side: 'before' | 'after';
+}
+export interface HippieCycle {
+    prefix: string;
+    length: number;
+    carets: readonly number[];
+    proposal: Pick<Variant, 'text' | 'source' | 'side'>;
+}
+export interface HippiePlan {
+    edits: TextEdit[];
+    carets: number[];
+    cycle: HippieCycle | null;
+    source: {
+        from: number;
+        to: number;
+    } | null;
+}
+export declare function hippieWords(text: string, hyphenated: boolean): Word[];
+export declare function hippiePrefixStart(text: string, caret: number, hyphenated: boolean): number;
+export declare function hippieMatches(word: string, prefix: string): boolean;
+export declare function planHippie(text: string, carets: readonly number[], primary: number, cycle: HippieCycle | null, direction: 1 | -1, options: HippieOptions): HippiePlan | null;
+export {};

package/dist/hippie.js

@@ -0,0 +1,183 @@
+import { isBraced, isWordCharacter } from './lexical.js';
+/* Texts of other documents longer than this are not read for words. */
+const MAX_SOURCE_LENGTH = 2_000_000;
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const LETTER = /\p{L}/u;
+function isWordPart(character, hyphenated) {
+    return isWordCharacter(character) || (hyphenated && (character === '-' || character === '*'));
+}
+/* The words of a text in order. A word has a letter or a digit in it. */
+export function hippieWords(text, hyphenated) {
+    const words = [];
+    let start = -1;
+    for (let i = 0; i <= text.length; i++) {
+        const inside = i < text.length && isWordPart(text[i], hyphenated);
+        if (inside && start < 0) {
+            start = i;
+        }
+        else if (!inside && start >= 0) {
+            const word = text.slice(start, i);
+            if (LETTER_OR_DIGIT.test(word)) {
+                words.push({ text: word, start, end: i });
+            }
+            start = -1;
+        }
+    }
+    return words;
+}
+/* Where the word before the caret starts, which is the caret itself when it is not in a word. */
+export function hippiePrefixStart(text, caret, hyphenated) {
+    let start = caret;
+    while (start > 0 && isWordPart(text[start - 1], hyphenated)) {
+        start--;
+    }
+    return LETTER_OR_DIGIT.test(text.slice(start, caret)) ? start : caret;
+}
+/* A letter that starts a camel hump (an uppercase after a lowercase) or follows a `_`, a `-` or a digit. */
+function isHump(word, index) {
+    const character = word[index];
+    const before = word[index - 1];
+    if (!LETTER.test(character)) {
+        return false;
+    }
+    const startsHump = character !== character.toLowerCase() && before !== before.toUpperCase();
+    return startsHump || /[\d_-]/.test(before);
+}
+function continues(word, prefix, wordIndex, prefixIndex) {
+    if (prefixIndex === prefix.length) {
+        return true;
+    }
+    for (let i = wordIndex; i < word.length; i++) {
+        // The character right after the last match continues it; any other has to start a hump.
+        if (i > wordIndex && !isHump(word, i)) {
+            continue;
+        }
+        if (word[i].toLowerCase() === prefix[prefixIndex].toLowerCase() && continues(word, prefix, i + 1, prefixIndex + 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+/* Whether a word is longer than the prefix and starts with it: the first character as typed, the rest by letters of any case or camel humps. */
+export function hippieMatches(word, prefix) {
+    if (word.length <= prefix.length) {
+        return false;
+    }
+    return prefix === '' || (word[0] === prefix[0] && continues(word, prefix, 1, 1));
+}
+/* The words of this document that complete the prefix: those before the primary caret ascending, then those after it. */
+function variantsHere(text, carets, primary, prefix, hyphenated) {
+    const before = new Map();
+    const after = new Map();
+    const words = hippieWords(text, hyphenated).filter((word) => !carets.some((caret) => word.start <= caret && caret <= word.end) && hippieMatches(word.text, prefix));
+    // The nearest occurrence of a repeated word stands: walk back from the caret before it, forward from it after.
+    for (const word of words.filter((entry) => entry.end <= primary).reverse()) {
+        if (!before.has(word.text)) {
+            before.set(word.text, { ...word, source: 'here', side: 'before' });
+        }
+    }
+    for (const word of words) {
+        if (word.end > primary && !after.has(word.text)) {
+            after.set(word.text, { ...word, source: 'here', side: 'after' });
+        }
+    }
+    return [...before.values()].reverse().concat([...after.values()]);
+}
+function variantsOther(sources, prefix, hyphenated) {
+    const seen = new Map();
+    for (const source of sources) {
+        if (source.length > MAX_SOURCE_LENGTH) {
+            continue;
+        }
+        for (const word of hippieWords(source, hyphenated)) {
+            if (!seen.has(word.text) && hippieMatches(word.text, prefix)) {
+                seen.set(word.text, { ...word, source: 'other', side: 'after' });
+            }
+        }
+    }
+    return [...seen.values()];
+}
+/* The first proposal going up is the nearest word above the caret, going down the nearest below it. */
+function homeOf(here, direction) {
+    const firstAfter = here.findIndex((variant) => variant.side === 'after');
+    if (direction === 1) {
+        return Math.max((firstAfter < 0 ? here.length : firstAfter) - 1, 0);
+    }
+    return firstAfter < 0 ? 0 : firstAfter;
+}
+/* Where a source runs out the cycle goes to the other documents, and from there back home. */
+function enter(here, other, direction, from) {
+    const otherStart = { source: 'other', index: direction === 1 ? other.length - 1 : 0 };
+    if (from === 'here' && other.length > 0) {
+        return otherStart;
+    }
+    if (here.length > 0) {
+        return { source: 'here', index: homeOf(here, direction) };
+    }
+    return other.length > 0 ? otherStart : null;
+}
+function step(here, other, current, direction) {
+    if (current === null) {
+        return enter(here, other, direction, 'other');
+    }
+    const list = current.source === 'here' ? here : other;
+    const index = current.index + (direction === 1 ? -1 : 1);
+    return index >= 0 && index < list.length ? { source: current.source, index } : enter(here, other, direction, current.source);
+}
+/* Where a word stands once the edits are made, or null when an edit reaches into it. */
+function sourceAfter(word, edits) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (edit.to <= word.start) {
+            delta += edit.text.length - (edit.to - edit.from);
+        }
+        else if (edit.from < word.end) {
+            return null;
+        }
+    }
+    return { from: word.start + delta, to: word.end + delta };
+}
+/*
+ * The next proposal of Hippie completion: the word before each caret is replaced by a longer word that starts the
+ * same, the nearest in this document first, and the following presses go through the others and then through the
+ * other open documents. `cycle` is what the last press left; pass it only while nothing has moved since.
+ * `carets` is ascending and `primary` is one of them.
+ */
+export function planHippie(text, carets, primary, cycle, direction, options) {
+    const hyphenated = !isBraced(options.language);
+    const prefix = cycle?.prefix ?? text.slice(hippiePrefixStart(text, primary, hyphenated), primary);
+    const here = variantsHere(text, carets, primary, prefix, hyphenated);
+    const other = variantsOther(options.wordSources?.() ?? [], prefix, hyphenated);
+    let current = null;
+    if (cycle !== null) {
+        const index = (cycle.proposal.source === 'here' ? here : other).findIndex((variant) => variant.text === cycle.proposal.text && variant.side === cycle.proposal.side);
+        current = index < 0 ? null : { source: cycle.proposal.source, index };
+    }
+    const next = step(here, other, current, direction);
+    const variant = next === null ? null : (next.source === 'here' ? here : other)[next.index];
+    if (variant === null && cycle === null) {
+        return null;
+    }
+    // With nothing left to offer, a cycle that is under way gives the prefix back.
+    const proposal = variant?.text ?? prefix;
+    const length = cycle?.length ?? prefix.length;
+    const edits = [];
+    const landed = [];
+    let end = 0;
+    let delta = 0;
+    for (const caret of carets) {
+        const from = Math.max(caret - length, end);
+        edits.push({ from, to: caret, text: proposal });
+        landed.push(from + delta + proposal.length);
+        delta += proposal.length - (caret - from);
+        end = caret;
+    }
+    return {
+        edits,
+        carets: landed,
+        cycle: variant === null
+            ? null
+            : { prefix, length: proposal.length, carets: landed, proposal: { text: variant.text, source: variant.source, side: variant.side } },
+        source: variant?.source === 'here' ? sourceAfter(variant, edits) : null
+    };
+}

package/dist/lexical.d.ts

@@ -21,3 +21,4 @@ export declare function isWordCharacter(character: string): boolean;
 export declare function startsExpression(word: string): boolean;
 export declare function startsExpressionAt(text: string, from: number, to: number): boolean;
 export declare function startsExpressionAfter(character: string): boolean;
+export declare function statementTerminator(language: string): ';' | null;

package/dist/lexical.js

@@ -78,3 +78,9 @@ export function startsExpressionAt(text, from, to) {
 export function startsExpressionAfter(character) {
     return expressionPunctuation.has(character);
 }
+/* The character that ends a statement in a language, or null where a line break does. */
+export function statementTerminator(language) {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|mjs|cjs|mts|cts|php|java|c|cpp|c\+\+|csharp|cs|rust|rs|dart|zig|glsl|hlsl|scala)$/i.test(language)
+        ? ';'
+        : null;
+}

package/dist/statement-move.d.ts

@@ -0,0 +1,21 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { FoldingRange } from './structure.ts';
+import type { Selection } from './types.ts';
+export interface MoveStatementOptions {
+    language: string;
+    unit: string;
+    tabSize: number;
+    structure: readonly FoldingRange[];
+    lineSpan?: (line: number) => {
+        first: number;
+        last: number;
+    };
+}
+export interface StatementMove extends EditPlan {
+    moves: {
+        from: number;
+        to: number;
+    }[];
+}
+export declare function statementMoveMode(language: string): 'braced' | 'indented' | null;
+export declare function planMoveStatement(source: EditSource, selections: readonly Selection[], direction: -1 | 1, options: MoveStatementOptions): StatementMove | null;