@adecore/editor-core 0.41.1 → 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

@@ -3,6 +3,8 @@ import type { DocumentLine } from './rope.ts';
 import type { FindMatch, FindNextOptions, FindOptions } from './search.ts';
 import type { FoldingOptions, FoldingRange } from './structure.ts';
 import type { CommandOptions, Disposable, EditOptions, EditorCommand, EditorSnapshot, Position, Selection, TextEdit } from './types.ts';
+import { type TodoMatch, type TodoOptions } from './todo.ts';
+import { type WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 export type { DocumentLine, FindMatch, FindNextOptions, FindOptions, FoldingOptions, FoldingRange };
 export interface OffsetRange {
     readonly from: number;
@@ -41,11 +43,17 @@ export declare class DocumentModel {
     private structureCache?;
     private selectionHistory;
     private typingContexts;
+    private readonly modified;
     private statementClosers;
     private arrows;
     private cloneSession;
     private occurrenceSession;
     occurrencesExhausted: boolean;
+    hippieSource: {
+        from: number;
+        to: number;
+    } | null;
+    private hippieState;
     private closers;
     private bracketCache?;
     private bracketTracker;
@@ -76,6 +84,12 @@ export declare class DocumentModel {
     replaceAll(query: string, replacement: string, options?: ReplaceAllOptions): number;
     replaceMatches(matches: readonly FindMatch[], replacement: string, options?: ReplaceOptions): number;
     getFoldingRanges(options?: FoldingOptions): FoldingRange[];
+    findTodos(language: string, options?: TodoOptions, first?: number, last?: number): TodoMatch[];
+    markSaved(): void;
+    getModifiedLines(): number[];
+    cleanUpWhitespace(options?: WhitespaceCleanupOptions & {
+        language?: string;
+    }): boolean;
     typeText(text: string, options?: TypeTextOptions): boolean;
     private takeBackArrows;
     private completeArrows;
@@ -115,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';
@@ -18,7 +22,13 @@ import { clampInteger, TextRope, ROPE_CHUNK_SIZE } from './rope.js';
 import { findMatches, findMatchFrom, replacementText, splitsSurrogate } from './search.js';
 import { dedupeFoldingRanges, deriveFoldingRanges, indentationColumn, scanStructure, tabWidth } from './structure.js';
 import { TypingContexts } from './typing-context.js';
+import { todosInLines } from './todo.js';
+import { planConvertIndents, planLineOrder } from './line-order.js';
+import { ModifiedStretches, planWhitespaceCleanup } from './whitespace-cleanup.js';
 import { isHumpBoundary, isWordBoundary } from './words.js';
+const LINE_ORDERS = { sortLines: 'sort', reverseLines: 'reverse', uniqueLines: 'unique' };
+/* Where trailing whitespace is part of a string's value, which a cleanup must not change. */
+const STRING_MODES = new Set(['quote', 'template', 'heredoc']);
 /* The platform's defaults: forward to a word's end and then the start of the next line, backward to a word's start and then the end of the line above. Deleting stops at every edge of a word and at both ends of a line. */
 const MOVE_FORWARD = { word: 'end', line: 'start' };
 const MOVE_BACKWARD = { word: 'start', line: 'end' };
@@ -33,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);
@@ -263,6 +274,7 @@ export class DocumentModel {
     structureCache;
     selectionHistory = [];
     typingContexts = new TypingContexts((line) => this.getLine(line));
+    modified = new ModifiedStretches();
     statementClosers = new Map();
     /* The carets that stand right after a `->` the editor completed, where the next keystroke decides whether it stays. */
     arrows = new Set();
@@ -270,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);
@@ -534,6 +549,41 @@ export class DocumentModel {
         markFileHeader(unique, getLine, this.getLineCount(), options.language);
         return options.hints === undefined ? unique : applyFoldHints(unique, options.hints, lineAt, getLine, slice, minimum);
     }
+    /* The TODO comments of the lines from `first` through `last`. It reads the lexer state the editing commands keep, so after an edit only the lines from the edit on are lexed again. */
+    findTodos(language, options = {}, first = 0, last = this.getLineCount() - 1) {
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index) => this.getLine(index),
+            context: (line, column) => this.typingContexts.at(line, column, language)
+        };
+        return todosInLines(source, options, first, last);
+    }
+    /* Forgets which lines changed, as when the text was just written to disk. */
+    markSaved() {
+        this.modified.clear();
+    }
+    /* The zero-based lines changed since `markSaved`, or since the document was made, undo and redo included. */
+    getModifiedLines() {
+        return this.modified.lines((offset) => this.rope.lineAt(offset), (line) => this.rope.lineBounds(line).start);
+    }
+    /*
+     * Cleans up the whitespace before a save, as one undo step: the trailing whitespace of the modified or
+     * of all lines, except on the lines with a caret and inside a multiline string of the language, the
+     * blank lines at the end, and a final line break. Returns whether the text changed.
+     */
+    cleanUpWhitespace(options = {}) {
+        const language = options.language ?? 'plaintext';
+        const modified = new Set(options.trailingWhitespace === 'modified' ? this.getModifiedLines() : []);
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index) => this.getLine(index),
+            newline: (index) => this.newlineAt(index),
+            keeps: (line, column) => STRING_MODES.has(this.typingContexts.at(line, column, language).mode)
+        };
+        const carets = new Set(this.selections.map((selection) => this.rope.lineAt(selection.head)));
+        const edits = planWhitespaceCleanup(source, options, { modified: (line) => modified.has(line), carets });
+        return edits.length > 0 && this.applyEdits(edits, { source: 'command' });
+    }
     /*
      * Types `text` at every caret as one keystroke would: it wraps a selection in a bracket or quote,
      * closes an opener, types over a closer that is already there and, in TypeScript, JavaScript and
@@ -661,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');
@@ -671,6 +740,15 @@ export class DocumentModel {
         if (command === 'joinLines' || command === 'toggleCase' || command === 'autoIndentLines') {
             return this.editLines(command, { language, unit });
         }
+        const order = LINE_ORDERS[command];
+        if (order !== undefined) {
+            const plan = planLineOrder(this.editSource(language), this.selections, order);
+            return plan !== null && this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
+        }
+        if (command === 'convertIndentsToSpaces' || command === 'convertIndentsToTabs') {
+            const edits = planConvertIndents(this.editSource(language), this.selections, tabSize, command === 'convertIndentsToSpaces');
+            return edits.length > 0 && this.applyEdits(edits, { source: 'command' });
+        }
         if (command === 'insertTab') {
             return this.insertTab(tabSize, options);
         }
@@ -1283,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));
@@ -1945,6 +2064,9 @@ export class DocumentModel {
     emit(changes, source, contentEdits, typed) {
         const snapshot = this.getSnapshot();
         if (changes) {
+            for (const transaction of changes) {
+                this.modified.record(transaction);
+            }
             snapshot.changes = changes.map((transaction) => transaction.map((change) => ({ ...change })));
             snapshot.source = source;
             if (typed) {

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 {};