@adecore/editor-core 0.41.1 → 0.42.0

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,6 +43,7 @@ export declare class DocumentModel {
     private structureCache?;
     private selectionHistory;
     private typingContexts;
+    private readonly modified;
     private statementClosers;
     private arrows;
     private cloneSession;
@@ -76,6 +79,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;

package/dist/document.js

@@ -18,7 +18,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' };
@@ -263,6 +269,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();
@@ -534,6 +541,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
@@ -671,6 +713,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);
         }
@@ -1945,6 +1996,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/index.d.ts

@@ -4,6 +4,9 @@ export { scanBrackets, type BracketIndex, type BracketMatch } from './brackets.t
 export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
 export { indentationColumn } from './structure.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from './doc-comments.ts';
+export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from './todo.ts';
+export { detectIndentation, type DetectedIndentation } from './line-order.ts';
+export type { TrailingWhitespace, WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 export type { FoldHints, FoldRangeHint, FoldRole, FoldSymbolHint, FoldingOptions, FoldingRange } from './structure.ts';
 export type { ChangeSource, CommandOptions, ContentEdit, Disposable, DocumentChange, EditOptions, EditorCommand, EditorSnapshot, Position, Selection, TextEdit } from './types.ts';
 export { changedSpan, changedSpans, type TextSpan } from './text-span.ts';

package/dist/index.js

@@ -3,4 +3,6 @@ export { scanBrackets } from './brackets.js';
 export { findMatches, iterateMatches, findMatchFrom, replacementText } from './search.js';
 export { indentationColumn } from './structure.js';
 export { findDocComments, MAX_DOC_COMMENTS } from './doc-comments.js';
+export { DEFAULT_TODO_WORDS, findTodos } from './todo.js';
+export { detectIndentation } from './line-order.js';
 export { changedSpan, changedSpans } from './text-span.js';

package/dist/line-order.d.ts

@@ -0,0 +1,10 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import type { Selection, TextEdit } from './types.ts';
+export type LineOrder = 'sort' | 'reverse' | 'unique';
+export declare function planLineOrder(source: EditSource, selections: readonly Selection[], order: LineOrder): EditPlan | null;
+export declare function planConvertIndents(source: EditSource, selections: readonly Selection[], tabSize: number, insertSpaces: boolean): TextEdit[];
+export interface DetectedIndentation {
+    insertSpaces: boolean;
+    tabSize?: number;
+}
+export declare function detectIndentation(text: string): DetectedIndentation | null;

package/dist/line-order.js

@@ -0,0 +1,156 @@
+import { indentText, rangeOf, whitespaceOf } from './line-text.js';
+import { indentationColumn } from './structure.js';
+/* The runs of lines the selections touch, or every line when nothing is selected. A selection that ends at the start of a line does not touch it. */
+function runsOf(source, selections) {
+    const ranges = selections.map(rangeOf).filter(({ from, to }) => from !== to);
+    const wanted = ranges.length > 0 ? ranges : [{ from: 0, to: source.line(source.lineCount - 1).end }];
+    const runs = [];
+    for (const { from, to } of [...wanted].sort((left, right) => left.from - right.from)) {
+        const first = source.lineAt(from);
+        let last = source.lineAt(to);
+        if (last > first && source.line(last).start === to) {
+            last--;
+        }
+        const previous = runs.at(-1);
+        if (previous !== undefined && first <= previous.last) {
+            previous.last = Math.max(previous.last, last);
+        }
+        else {
+            runs.push({ first, last });
+        }
+    }
+    return runs;
+}
+function reorder(lines, order) {
+    if (order === 'reverse') {
+        return [...lines].reverse();
+    }
+    if (order === 'unique') {
+        return [...new Set(lines)];
+    }
+    return [...lines].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+}
+/*
+ * Sorts, reverses or dedupes the lines the selections touch, or the whole text with nothing selected,
+ * each run of lines on its own. Every line break stays where it was, so a last line without one stays
+ * without one. Sorting compares by code unit, so capitals come first, and keeps equal lines in order;
+ * dedupe keeps the first of equal lines. A selection keeps its offsets, as far as the text still reaches.
+ */
+export function planLineOrder(source, selections, order) {
+    const edits = [];
+    const runs = [];
+    for (const { first, last } of runsOf(source, selections)) {
+        if (last <= first) {
+            continue;
+        }
+        const lines = [];
+        const breaks = [];
+        for (let index = first; index <= last; index++) {
+            lines.push(source.line(index).text);
+            if (index < last) {
+                breaks.push(source.newline(index));
+            }
+        }
+        const result = reorder(lines, order);
+        const text = result.map((line, index) => line + (index < result.length - 1 ? breaks[index] : '')).join('');
+        const from = source.line(first).start;
+        const to = source.line(last).end;
+        if (text !== source.slice(from, to)) {
+            edits.push({ from, to, text });
+            runs.push({ from, to, length: text.length });
+        }
+    }
+    if (edits.length === 0) {
+        return null;
+    }
+    const place = (offset) => {
+        let shift = 0;
+        for (const run of runs) {
+            if (offset < run.from) {
+                break;
+            }
+            if (offset < run.to) {
+                return Math.min(offset, run.from + run.length) + shift;
+            }
+            shift += run.length - (run.to - run.from);
+        }
+        return offset + shift;
+    };
+    return { edits, selections: selections.map((selection) => ({ anchor: place(selection.anchor), head: place(selection.head) })) };
+}
+/*
+ * Rewrites the indentation of the lines the selections touch, or of every line with nothing selected:
+ * to spaces with each tab taken to its stop, or to as many tabs as fit and the spaces left over. Only the
+ * whitespace a line starts with changes.
+ */
+export function planConvertIndents(source, selections, tabSize, insertSpaces) {
+    const edits = [];
+    for (const { first, last } of runsOf(source, selections)) {
+        for (let index = first; index <= last; index++) {
+            const line = source.line(index);
+            const current = whitespaceOf(line.text);
+            const target = indentText(indentationColumn(current, tabSize), { tabSize, insertSpaces });
+            if (current !== target) {
+                edits.push({ from: line.start, to: line.start + current.length, text: target });
+            }
+        }
+    }
+    return edits;
+}
+/* Past this many lines the rest says nothing new. */
+const DETECT_LINES = 10_000;
+const MAX_INDENT_SIZE = 8;
+/*
+ * Reads the indentation a text already uses, to edit it the same way. Tabs win when more lines start with
+ * a tab than with spaces; otherwise the width of one level is the step between a line and a deeper one
+ * after it that occurs most often. On a tie the step more indents are a multiple of wins, so a line
+ * aligned under a parenthesis does not pass for a level, and then the smaller. The lines inside a block
+ * comment that start with a star are left out, since their single space is no level. Null when no line says.
+ */
+export function detectIndentation(text) {
+    const steps = new Map();
+    const widths = [];
+    let tabs = 0;
+    let spaces = 0;
+    let previous = 0;
+    let count = 0;
+    for (const line of text.split(/\r\n|\r|\n/)) {
+        if (++count > DETECT_LINES) {
+            break;
+        }
+        const indent = whitespaceOf(line);
+        const content = line.slice(indent.length);
+        if (content === '' || content.startsWith('*')) {
+            continue;
+        }
+        if (indent.startsWith('\t')) {
+            tabs++;
+            previous = -1;
+            continue;
+        }
+        if (indent.includes('\t')) {
+            previous = -1;
+            continue;
+        }
+        if (indent.length > 0) {
+            spaces++;
+            widths.push(indent.length);
+        }
+        const step = indent.length - previous;
+        if (previous >= 0 && step > 0 && step <= MAX_INDENT_SIZE) {
+            steps.set(step, (steps.get(step) ?? 0) + 1);
+        }
+        previous = indent.length;
+    }
+    if (tabs > spaces) {
+        return { insertSpaces: false };
+    }
+    let best = null;
+    for (const [size, uses] of steps) {
+        const fits = widths.filter((width) => width % size === 0).length;
+        if (best === null || uses > best.uses || (uses === best.uses && (fits > best.fits || (fits === best.fits && size < best.size)))) {
+            best = { size, uses, fits };
+        }
+    }
+    return best === null ? null : { insertSpaces: true, tabSize: best.size };
+}

package/dist/todo.d.ts

@@ -0,0 +1,21 @@
+import type { DocumentLine } from './rope.ts';
+import { type TypingContext } from './typing-context.ts';
+export declare const DEFAULT_TODO_WORDS: readonly string[];
+export interface TodoMatch {
+    from: number;
+    to: number;
+    line: number;
+    word: string;
+}
+export interface TodoOptions {
+    words?: readonly string[];
+}
+export interface TodoSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    context(line: number, column: number): TypingContext;
+}
+export declare function todoPattern(words?: readonly string[]): RegExp | null;
+export declare function todosOnLine(source: TodoSource, index: number, pattern: RegExp, words: readonly string[]): TodoMatch[];
+export declare function todosInLines(source: TodoSource, options?: TodoOptions, first?: number, last?: number): TodoMatch[];
+export declare function findTodos(text: string, language: string, options?: TodoOptions): TodoMatch[];

package/dist/todo.js

@@ -0,0 +1,72 @@
+import { TypingContexts } from './typing-context.js';
+/* The words a TODO comment starts with when a host names none. */
+export const DEFAULT_TODO_WORDS = ['TODO', 'FIXME'];
+const CLOSERS = { 'block-comment': '*/', 'html-comment': '-->' };
+function escape(word) {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/* Null when there is nothing to look for. */
+export function todoPattern(words = DEFAULT_TODO_WORDS) {
+    const usable = words.map((word) => word.trim()).filter((word) => word !== '');
+    if (usable.length === 0) {
+        return null;
+    }
+    // Longest first, so `TODO` does not stop a list that also has `TODO_LATER` short.
+    const alternatives = [...usable].sort((left, right) => right.length - left.length).map(escape);
+    return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${alternatives.join('|')})(?![\\p{L}\\p{N}_])`, 'giu');
+}
+/*
+ * The TODOs on one line. A word counts only where the lexer says a comment is, so one in a string or in
+ * code is no TODO, and a second word in the same comment is part of the first one's TODO.
+ */
+export function todosOnLine(source, index, pattern, words) {
+    const line = source.line(index);
+    const result = [];
+    pattern.lastIndex = 0;
+    for (let found = pattern.exec(line.text); found !== null; found = pattern.exec(line.text)) {
+        const context = source.context(index, found.index);
+        const closer = CLOSERS[context.mode];
+        if (context.mode !== 'line-comment' && closer === undefined) {
+            continue;
+        }
+        const close = closer === undefined ? -1 : line.text.indexOf(closer, found.index + found[0].length);
+        const end = close === -1 ? line.text.length : close;
+        const word = words.find((candidate) => candidate.trim().toLowerCase() === found[0].toLowerCase()) ?? found[0];
+        result.push({ from: line.start + found.index, to: line.start + end, line: index, word: word.trim() });
+        pattern.lastIndex = Math.max(pattern.lastIndex, end);
+    }
+    return result;
+}
+/* Every TODO of the lines from `first` through `last`, in order. */
+export function todosInLines(source, options = {}, first = 0, last = source.lineCount - 1) {
+    const words = options.words ?? DEFAULT_TODO_WORDS;
+    const pattern = todoPattern(words);
+    if (pattern === null) {
+        return [];
+    }
+    const result = [];
+    for (let index = Math.max(0, first); index <= Math.min(last, source.lineCount - 1); index++) {
+        result.push(...todosOnLine(source, index, pattern, words));
+    }
+    return result;
+}
+/*
+ * The TODO comments of a text, for a host that lists them. The language decides what a comment is, as
+ * it does for the editor's own commands, and a language without comments has none.
+ */
+export function findTodos(text, language, options = {}) {
+    const lines = splitLines(text);
+    const contexts = new TypingContexts((index) => lines[index]);
+    return todosInLines({ lineCount: lines.length, line: (index) => lines[index], context: (line, column) => contexts.at(line, column, language) }, options);
+}
+function splitLines(text) {
+    const lines = [];
+    const breaks = /\r\n|\r|\n/g;
+    let start = 0;
+    for (let found = breaks.exec(text); found !== null; found = breaks.exec(text)) {
+        lines.push({ start, end: found.index, next: found.index + found[0].length, text: text.slice(start, found.index) });
+        start = found.index + found[0].length;
+    }
+    lines.push({ start, end: text.length, next: text.length, text: text.slice(start) });
+    return lines;
+}

package/dist/types.d.ts

@@ -43,7 +43,7 @@ export interface EditOptions {
     joinPrevious?: boolean;
     typed?: boolean;
 }
-export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine';
+export type EditorCommand = 'undo' | 'redo' | 'selectAll' | 'smartHome' | 'smartEnd' | 'selectSmartHome' | 'selectSmartEnd' | 'wordLeft' | 'wordRight' | 'selectWordLeft' | 'selectWordRight' | 'deleteWordLeft' | 'deleteWordRight' | 'camelLeft' | 'camelRight' | 'selectCamelLeft' | 'selectCamelRight' | 'deleteCamelLeft' | 'deleteCamelRight' | 'expandSelection' | 'shrinkSelection' | 'smartBackspace' | 'deleteForward' | 'duplicateLine' | 'deleteLine' | 'moveLineUp' | 'moveLineDown' | 'toggleLineComment' | 'toggleBlockComment' | 'insertTab' | 'indent' | 'outdent' | 'insertNewline' | 'startNewLine' | 'startNewLineBefore' | 'splitLine' | 'joinLines' | 'toggleCase' | 'autoIndentLines' | 'addCaretAbove' | 'addCaretBelow' | 'selectNextOccurrence' | 'unselectOccurrence' | 'selectAllOccurrences' | 'addCaretPerSelectedLine' | 'sortLines' | 'reverseLines' | 'uniqueLines' | 'convertIndentsToSpaces' | 'convertIndentsToTabs';
 export interface CommandOptions {
     tabSize?: number;
     insertSpaces?: boolean;

package/dist/whitespace-cleanup.d.ts

@@ -0,0 +1,26 @@
+import type { DocumentLine } from './rope.ts';
+import type { DocumentChange, TextEdit } from './types.ts';
+export type TrailingWhitespace = 'off' | 'modified' | 'all';
+export interface WhitespaceCleanupOptions {
+    trailingWhitespace?: TrailingWhitespace;
+    keepCaretLines?: boolean;
+    removeTrailingBlankLines?: boolean;
+    ensureFinalNewline?: boolean;
+}
+export interface CleanupSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    newline(index: number): string;
+    keeps?(line: number, column: number): boolean;
+}
+export interface CleanupLines {
+    modified(line: number): boolean;
+    carets: ReadonlySet<number>;
+}
+export declare function planWhitespaceCleanup(source: CleanupSource, options: WhitespaceCleanupOptions, lines: CleanupLines): TextEdit[];
+export declare class ModifiedStretches {
+    private stretches;
+    clear(): void;
+    record(changes: readonly DocumentChange[]): void;
+    lines(lineAt: (offset: number) => number, lineStart: (line: number) => number): number[];
+}

package/dist/whitespace-cleanup.js

@@ -0,0 +1,100 @@
+import { isBlank } from './line-text.js';
+/* The edits that clean up the whitespace of a text before it is saved, all in the coordinates of the text as it is. */
+export function planWhitespaceCleanup(source, options, lines) {
+    const edits = [];
+    let lastText = source.lineCount - 1;
+    if (options.removeTrailingBlankLines === true) {
+        while (lastText >= 0 && isBlank(source.line(lastText).text)) {
+            lastText--;
+        }
+    }
+    const mode = options.trailingWhitespace ?? 'off';
+    for (let index = 0; mode !== 'off' && index <= lastText; index++) {
+        const line = source.line(index);
+        const trailing = /[\t ]+$/.exec(line.text);
+        if (trailing === null) {
+            continue;
+        }
+        const kept = trailing.index;
+        if ((mode === 'modified' && !lines.modified(index)) ||
+            (options.keepCaretLines !== false && lines.carets.has(index)) ||
+            source.keeps?.(index, kept) === true) {
+            continue;
+        }
+        edits.push({ from: line.start + kept, to: line.end, text: '' });
+    }
+    const last = source.line(source.lineCount - 1);
+    if (lastText < source.lineCount - 1) {
+        edits.push({ from: lastText < 0 ? 0 : source.line(lastText + 1).start, to: last.end, text: '' });
+    }
+    // A last line that is empty, or that the cleanup emptied, already stands after a line break.
+    const end = source.line(source.lineCount - 1);
+    const emptied = edits.some((edit) => edit.from === end.start && edit.to === end.end);
+    if (options.ensureFinalNewline === true && lastText === source.lineCount - 1 && end.text !== '' && !emptied) {
+        edits.push({ from: end.end, to: end.end, text: source.lineCount > 1 ? source.newline(0) : '\n' });
+    }
+    return edits;
+}
+/*
+ * The stretches of a text that changed since it was last marked as saved, followed through every
+ * change after it, undo included. A deletion leaves an empty stretch, which still marks its line.
+ */
+export class ModifiedStretches {
+    stretches = [];
+    clear() {
+        this.stretches = [];
+    }
+    /* One transaction, its changes in the coordinates of the text before it. */
+    record(changes) {
+        const ordered = [...changes].sort((left, right) => left.from - right.from);
+        let index = 0;
+        let shift = 0;
+        // The stretches are in order and apart, so one walk over the changes maps all their offsets.
+        const map = (offset, end) => {
+            for (; index < ordered.length; index++) {
+                const change = ordered[index];
+                if (offset < change.from || (offset === change.from && !end)) {
+                    break;
+                }
+                if (offset < change.to) {
+                    return change.from + shift + (end ? change.insertedLength : 0);
+                }
+                shift += change.insertedLength - (change.to - change.from);
+            }
+            return offset + shift;
+        };
+        const next = this.stretches.map((stretch) => ({ from: map(stretch.from, false), to: map(stretch.to, true) }));
+        shift = 0;
+        for (const change of ordered) {
+            const from = change.from + shift;
+            next.push({ from, to: from + change.insertedLength });
+            shift += change.insertedLength - (change.to - change.from);
+        }
+        next.sort((left, right) => left.from - right.from);
+        this.stretches = [];
+        for (const stretch of next) {
+            const previous = this.stretches.at(-1);
+            if (previous !== undefined && stretch.from <= previous.to) {
+                previous.to = Math.max(previous.to, stretch.to);
+            }
+            else {
+                this.stretches.push({ ...stretch });
+            }
+        }
+    }
+    /* The zero-based lines the stretches touch, in order. A stretch that ends at the start of a line, such as an inserted line, does not touch it. */
+    lines(lineAt, lineStart) {
+        const result = [];
+        for (const { from, to } of this.stretches) {
+            const first = lineAt(from);
+            let last = lineAt(to);
+            if (last > first && lineStart(last) === to) {
+                last--;
+            }
+            for (let line = Math.max(first, (result.at(-1) ?? -1) + 1); line <= last; line++) {
+                result.push(line);
+            }
+        }
+        return result;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.41.1",
+  "version": "0.42.0",
   "type": "module",
   "exports": {
     ".": {

package/src/document.ts

@@ -37,10 +37,17 @@ import type {
 } from './types.ts';
 import { TypingContexts } from './typing-context.ts';
 import type { TypingContext } from './typing-context.ts';
+import { todosInLines, type TodoMatch, type TodoOptions } from './todo.ts';
+import { type LineOrder, planConvertIndents, planLineOrder } from './line-order.ts';
+import { ModifiedStretches, planWhitespaceCleanup, type WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 import { isHumpBoundary, isWordBoundary } from './words.ts';
 
 export type { DocumentLine, FindMatch, FindNextOptions, FindOptions, FoldingOptions, FoldingRange };
 
+const LINE_ORDERS: Partial<Record<EditorCommand, LineOrder>> = { 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<TypingContext['mode']>(['quote', 'template', 'heredoc']);
+
 export interface OffsetRange {
     readonly from: number;
     readonly to: number;
@@ -456,6 +463,7 @@ export class DocumentModel {
     private structureCache?: StructureRange[];
     private selectionHistory: Selection[][] = [];
     private typingContexts = new TypingContexts((line) => this.getLine(line));
+    private readonly modified = new ModifiedStretches();
     private statementClosers = new Map<number, { text: string; language: string }>();
     /* The carets that stand right after a `->` the editor completed, where the next keystroke decides whether it stays. */
     private arrows = new Set<number>();
@@ -814,6 +822,52 @@ export class DocumentModel {
         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: string, options: TodoOptions = {}, first = 0, last = this.getLineCount() - 1): TodoMatch[] {
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index: number) => this.getLine(index),
+            context: (line: number, column: number) => 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(): void {
+        this.modified.clear();
+    }
+
+    /* The zero-based lines changed since `markSaved`, or since the document was made, undo and redo included. */
+    getModifiedLines(): number[] {
+        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: WhitespaceCleanupOptions & { language?: string } = {}): boolean {
+        const language = options.language ?? 'plaintext';
+        const modified = new Set(options.trailingWhitespace === 'modified' ? this.getModifiedLines() : []);
+
+        const source = {
+            lineCount: this.getLineCount(),
+            line: (index: number) => this.getLine(index),
+            newline: (index: number) => this.newlineAt(index),
+            keeps: (line: number, column: number) => 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
@@ -1006,6 +1060,20 @@ export class DocumentModel {
             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);
         }
@@ -2738,6 +2806,10 @@ export class DocumentModel {
         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;
 

package/src/index.ts

@@ -4,6 +4,9 @@ export { scanBrackets, type BracketIndex, type BracketMatch } from './brackets.t
 export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
 export { indentationColumn } from './structure.ts';
 export { findDocComments, MAX_DOC_COMMENTS, type DocComment } from './doc-comments.ts';
+export { DEFAULT_TODO_WORDS, findTodos, type TodoMatch, type TodoOptions } from './todo.ts';
+export { detectIndentation, type DetectedIndentation } from './line-order.ts';
+export type { TrailingWhitespace, WhitespaceCleanupOptions } from './whitespace-cleanup.ts';
 export type { FoldHints, FoldRangeHint, FoldRole, FoldSymbolHint, FoldingOptions, FoldingRange } from './structure.ts';
 
 export type {

package/src/line-order.ts

@@ -0,0 +1,215 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import { indentText, rangeOf, whitespaceOf } from './line-text.ts';
+import { indentationColumn } from './structure.ts';
+import type { Selection, TextEdit } from './types.ts';
+
+export type LineOrder = 'sort' | 'reverse' | 'unique';
+
+interface LineRun {
+    first: number;
+    last: number;
+}
+
+/* The runs of lines the selections touch, or every line when nothing is selected. A selection that ends at the start of a line does not touch it. */
+function runsOf(source: EditSource, selections: readonly Selection[]): LineRun[] {
+    const ranges = selections.map(rangeOf).filter(({ from, to }) => from !== to);
+    const wanted = ranges.length > 0 ? ranges : [{ from: 0, to: source.line(source.lineCount - 1).end }];
+    const runs: LineRun[] = [];
+
+    for (const { from, to } of [...wanted].sort((left, right) => left.from - right.from)) {
+        const first = source.lineAt(from);
+        let last = source.lineAt(to);
+
+        if (last > first && source.line(last).start === to) {
+            last--;
+        }
+
+        const previous = runs.at(-1);
+
+        if (previous !== undefined && first <= previous.last) {
+            previous.last = Math.max(previous.last, last);
+        } else {
+            runs.push({ first, last });
+        }
+    }
+
+    return runs;
+}
+
+function reorder(lines: readonly string[], order: LineOrder): string[] {
+    if (order === 'reverse') {
+        return [...lines].reverse();
+    }
+
+    if (order === 'unique') {
+        return [...new Set(lines)];
+    }
+
+    return [...lines].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+}
+
+/*
+ * Sorts, reverses or dedupes the lines the selections touch, or the whole text with nothing selected,
+ * each run of lines on its own. Every line break stays where it was, so a last line without one stays
+ * without one. Sorting compares by code unit, so capitals come first, and keeps equal lines in order;
+ * dedupe keeps the first of equal lines. A selection keeps its offsets, as far as the text still reaches.
+ */
+export function planLineOrder(source: EditSource, selections: readonly Selection[], order: LineOrder): EditPlan | null {
+    const edits: TextEdit[] = [];
+    const runs: { from: number; to: number; length: number }[] = [];
+
+    for (const { first, last } of runsOf(source, selections)) {
+        if (last <= first) {
+            continue;
+        }
+
+        const lines: string[] = [];
+        const breaks: string[] = [];
+
+        for (let index = first; index <= last; index++) {
+            lines.push(source.line(index).text);
+
+            if (index < last) {
+                breaks.push(source.newline(index));
+            }
+        }
+
+        const result = reorder(lines, order);
+        const text = result.map((line, index) => line + (index < result.length - 1 ? breaks[index]! : '')).join('');
+        const from = source.line(first).start;
+        const to = source.line(last).end;
+
+        if (text !== source.slice(from, to)) {
+            edits.push({ from, to, text });
+            runs.push({ from, to, length: text.length });
+        }
+    }
+
+    if (edits.length === 0) {
+        return null;
+    }
+
+    const place = (offset: number): number => {
+        let shift = 0;
+
+        for (const run of runs) {
+            if (offset < run.from) {
+                break;
+            }
+
+            if (offset < run.to) {
+                return Math.min(offset, run.from + run.length) + shift;
+            }
+
+            shift += run.length - (run.to - run.from);
+        }
+
+        return offset + shift;
+    };
+
+    return { edits, selections: selections.map((selection) => ({ anchor: place(selection.anchor), head: place(selection.head) })) };
+}
+
+/*
+ * Rewrites the indentation of the lines the selections touch, or of every line with nothing selected:
+ * to spaces with each tab taken to its stop, or to as many tabs as fit and the spaces left over. Only the
+ * whitespace a line starts with changes.
+ */
+export function planConvertIndents(source: EditSource, selections: readonly Selection[], tabSize: number, insertSpaces: boolean): TextEdit[] {
+    const edits: TextEdit[] = [];
+
+    for (const { first, last } of runsOf(source, selections)) {
+        for (let index = first; index <= last; index++) {
+            const line = source.line(index);
+            const current = whitespaceOf(line.text);
+            const target = indentText(indentationColumn(current, tabSize), { tabSize, insertSpaces });
+
+            if (current !== target) {
+                edits.push({ from: line.start, to: line.start + current.length, text: target });
+            }
+        }
+    }
+
+    return edits;
+}
+
+/* The indentation a text uses: spaces with the width of one level, or tabs, whose width a text cannot say. */
+export interface DetectedIndentation {
+    insertSpaces: boolean;
+    tabSize?: number;
+}
+
+/* Past this many lines the rest says nothing new. */
+const DETECT_LINES = 10_000;
+const MAX_INDENT_SIZE = 8;
+
+/*
+ * Reads the indentation a text already uses, to edit it the same way. Tabs win when more lines start with
+ * a tab than with spaces; otherwise the width of one level is the step between a line and a deeper one
+ * after it that occurs most often. On a tie the step more indents are a multiple of wins, so a line
+ * aligned under a parenthesis does not pass for a level, and then the smaller. The lines inside a block
+ * comment that start with a star are left out, since their single space is no level. Null when no line says.
+ */
+export function detectIndentation(text: string): DetectedIndentation | null {
+    const steps = new Map<number, number>();
+    const widths: number[] = [];
+    let tabs = 0;
+    let spaces = 0;
+    let previous = 0;
+    let count = 0;
+
+    for (const line of text.split(/\r\n|\r|\n/)) {
+        if (++count > DETECT_LINES) {
+            break;
+        }
+
+        const indent = whitespaceOf(line);
+        const content = line.slice(indent.length);
+
+        if (content === '' || content.startsWith('*')) {
+            continue;
+        }
+
+        if (indent.startsWith('\t')) {
+            tabs++;
+            previous = -1;
+
+            continue;
+        }
+
+        if (indent.includes('\t')) {
+            previous = -1;
+
+            continue;
+        }
+
+        if (indent.length > 0) {
+            spaces++;
+            widths.push(indent.length);
+        }
+
+        const step = indent.length - previous;
+
+        if (previous >= 0 && step > 0 && step <= MAX_INDENT_SIZE) {
+            steps.set(step, (steps.get(step) ?? 0) + 1);
+        }
+
+        previous = indent.length;
+    }
+
+    if (tabs > spaces) {
+        return { insertSpaces: false };
+    }
+
+    let best: { size: number; uses: number; fits: number } | null = null;
+
+    for (const [size, uses] of steps) {
+        const fits = widths.filter((width) => width % size === 0).length;
+
+        if (best === null || uses > best.uses || (uses === best.uses && (fits > best.fits || (fits === best.fits && size < best.size)))) {
+            best = { size, uses, fits };
+        }
+    }
+
+    return best === null ? null : { insertSpaces: true, tabSize: best.size };
+}

package/src/todo.ts

@@ -0,0 +1,118 @@
+import type { DocumentLine } from './rope.ts';
+import { type TypingContext, TypingContexts } from './typing-context.ts';
+
+/* The words a TODO comment starts with when a host names none. */
+export const DEFAULT_TODO_WORDS: readonly string[] = ['TODO', 'FIXME'];
+
+/* A TODO in a comment: from its word to the end of the comment on that line. */
+export interface TodoMatch {
+    from: number;
+    to: number;
+    /* Zero-based. */
+    line: number;
+    /* The word of the list it matched, as the list writes it. */
+    word: string;
+}
+
+export interface TodoOptions {
+    /* Matched as whole words in any case. `DEFAULT_TODO_WORDS` without them; an empty list finds nothing. */
+    words?: readonly string[];
+}
+
+/* What finding the TODOs of a document reads of it. */
+export interface TodoSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    context(line: number, column: number): TypingContext;
+}
+
+const CLOSERS: Partial<Record<TypingContext['mode'], string>> = { 'block-comment': '*/', 'html-comment': '-->' };
+
+function escape(word: string): string {
+    return word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/* Null when there is nothing to look for. */
+export function todoPattern(words: readonly string[] = DEFAULT_TODO_WORDS): RegExp | null {
+    const usable = words.map((word) => word.trim()).filter((word) => word !== '');
+
+    if (usable.length === 0) {
+        return null;
+    }
+
+    // Longest first, so `TODO` does not stop a list that also has `TODO_LATER` short.
+    const alternatives = [...usable].sort((left, right) => right.length - left.length).map(escape);
+
+    return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${alternatives.join('|')})(?![\\p{L}\\p{N}_])`, 'giu');
+}
+
+/*
+ * The TODOs on one line. A word counts only where the lexer says a comment is, so one in a string or in
+ * code is no TODO, and a second word in the same comment is part of the first one's TODO.
+ */
+export function todosOnLine(source: TodoSource, index: number, pattern: RegExp, words: readonly string[]): TodoMatch[] {
+    const line = source.line(index);
+    const result: TodoMatch[] = [];
+    pattern.lastIndex = 0;
+
+    for (let found = pattern.exec(line.text); found !== null; found = pattern.exec(line.text)) {
+        const context = source.context(index, found.index);
+        const closer = CLOSERS[context.mode];
+
+        if (context.mode !== 'line-comment' && closer === undefined) {
+            continue;
+        }
+
+        const close = closer === undefined ? -1 : line.text.indexOf(closer, found.index + found[0].length);
+        const end = close === -1 ? line.text.length : close;
+        const word = words.find((candidate) => candidate.trim().toLowerCase() === found[0].toLowerCase()) ?? found[0];
+        result.push({ from: line.start + found.index, to: line.start + end, line: index, word: word.trim() });
+        pattern.lastIndex = Math.max(pattern.lastIndex, end);
+    }
+
+    return result;
+}
+
+/* Every TODO of the lines from `first` through `last`, in order. */
+export function todosInLines(source: TodoSource, options: TodoOptions = {}, first = 0, last = source.lineCount - 1): TodoMatch[] {
+    const words = options.words ?? DEFAULT_TODO_WORDS;
+    const pattern = todoPattern(words);
+
+    if (pattern === null) {
+        return [];
+    }
+
+    const result: TodoMatch[] = [];
+
+    for (let index = Math.max(0, first); index <= Math.min(last, source.lineCount - 1); index++) {
+        result.push(...todosOnLine(source, index, pattern, words));
+    }
+
+    return result;
+}
+
+/*
+ * The TODO comments of a text, for a host that lists them. The language decides what a comment is, as
+ * it does for the editor's own commands, and a language without comments has none.
+ */
+export function findTodos(text: string, language: string, options: TodoOptions = {}): TodoMatch[] {
+    const lines = splitLines(text);
+    const contexts = new TypingContexts((index) => lines[index]!);
+
+    return todosInLines({ lineCount: lines.length, line: (index) => lines[index]!, context: (line, column) => contexts.at(line, column, language) }, options);
+}
+
+function splitLines(text: string): DocumentLine[] {
+    const lines: DocumentLine[] = [];
+    const breaks = /\r\n|\r|\n/g;
+    let start = 0;
+
+    for (let found = breaks.exec(text); found !== null; found = breaks.exec(text)) {
+        lines.push({ start, end: found.index, next: found.index + found[0].length, text: text.slice(start, found.index) });
+        start = found.index + found[0].length;
+    }
+
+    lines.push({ start, end: text.length, next: text.length, text: text.slice(start) });
+
+    return lines;
+}

package/src/types.ts

@@ -110,7 +110,12 @@ export type EditorCommand =
     | 'selectNextOccurrence'
     | 'unselectOccurrence'
     | 'selectAllOccurrences'
-    | 'addCaretPerSelectedLine';
+    | 'addCaretPerSelectedLine'
+    | 'sortLines'
+    | 'reverseLines'
+    | 'uniqueLines'
+    | 'convertIndentsToSpaces'
+    | 'convertIndentsToTabs';
 
 export interface CommandOptions {
     /* Clamped to 1 through 16. */

package/src/whitespace-cleanup.ts

@@ -0,0 +1,162 @@
+import { isBlank } from './line-text.ts';
+import type { DocumentLine } from './rope.ts';
+import type { DocumentChange, TextEdit } from './types.ts';
+
+/* Which lines lose the spaces and tabs at their end. */
+export type TrailingWhitespace = 'off' | 'modified' | 'all';
+
+export interface WhitespaceCleanupOptions {
+    /* Off unless set. `modified` reads the lines changed since the document was last marked as saved. */
+    trailingWhitespace?: TrailingWhitespace;
+    /* The lines a caret is on keep their trailing whitespace, so a person typing there does not lose it. On unless false. */
+    keepCaretLines?: boolean;
+    /* The blank lines at the end go, up to the last line with text and its line break. Off unless true. */
+    removeTrailingBlankLines?: boolean;
+    /* A text that does not end in a line break gets one, in the style of its first. Off unless true. */
+    ensureFinalNewline?: boolean;
+}
+
+/* What the cleanup reads of a document. */
+export interface CleanupSource {
+    lineCount: number;
+    line(index: number): DocumentLine;
+    newline(index: number): string;
+    /* Whether trailing whitespace starting at this column belongs to the text itself, such as inside a multiline string. */
+    keeps?(line: number, column: number): boolean;
+}
+
+export interface CleanupLines {
+    modified(line: number): boolean;
+    carets: ReadonlySet<number>;
+}
+
+/* The edits that clean up the whitespace of a text before it is saved, all in the coordinates of the text as it is. */
+export function planWhitespaceCleanup(source: CleanupSource, options: WhitespaceCleanupOptions, lines: CleanupLines): TextEdit[] {
+    const edits: TextEdit[] = [];
+    let lastText = source.lineCount - 1;
+
+    if (options.removeTrailingBlankLines === true) {
+        while (lastText >= 0 && isBlank(source.line(lastText).text)) {
+            lastText--;
+        }
+    }
+
+    const mode = options.trailingWhitespace ?? 'off';
+
+    for (let index = 0; mode !== 'off' && index <= lastText; index++) {
+        const line = source.line(index);
+        const trailing = /[\t ]+$/.exec(line.text);
+
+        if (trailing === null) {
+            continue;
+        }
+
+        const kept = trailing.index;
+
+        if (
+            (mode === 'modified' && !lines.modified(index)) ||
+            (options.keepCaretLines !== false && lines.carets.has(index)) ||
+            source.keeps?.(index, kept) === true
+        ) {
+            continue;
+        }
+
+        edits.push({ from: line.start + kept, to: line.end, text: '' });
+    }
+
+    const last = source.line(source.lineCount - 1);
+
+    if (lastText < source.lineCount - 1) {
+        edits.push({ from: lastText < 0 ? 0 : source.line(lastText + 1).start, to: last.end, text: '' });
+    }
+
+    // A last line that is empty, or that the cleanup emptied, already stands after a line break.
+    const end = source.line(source.lineCount - 1);
+    const emptied = edits.some((edit) => edit.from === end.start && edit.to === end.end);
+
+    if (options.ensureFinalNewline === true && lastText === source.lineCount - 1 && end.text !== '' && !emptied) {
+        edits.push({ from: end.end, to: end.end, text: source.lineCount > 1 ? source.newline(0) : '\n' });
+    }
+
+    return edits;
+}
+
+/*
+ * The stretches of a text that changed since it was last marked as saved, followed through every
+ * change after it, undo included. A deletion leaves an empty stretch, which still marks its line.
+ */
+export class ModifiedStretches {
+    private stretches: { from: number; to: number }[] = [];
+
+    clear(): void {
+        this.stretches = [];
+    }
+
+    /* One transaction, its changes in the coordinates of the text before it. */
+    record(changes: readonly DocumentChange[]): void {
+        const ordered = [...changes].sort((left, right) => left.from - right.from);
+        let index = 0;
+        let shift = 0;
+
+        // The stretches are in order and apart, so one walk over the changes maps all their offsets.
+        const map = (offset: number, end: boolean): number => {
+            for (; index < ordered.length; index++) {
+                const change = ordered[index]!;
+
+                if (offset < change.from || (offset === change.from && !end)) {
+                    break;
+                }
+
+                if (offset < change.to) {
+                    return change.from + shift + (end ? change.insertedLength : 0);
+                }
+
+                shift += change.insertedLength - (change.to - change.from);
+            }
+
+            return offset + shift;
+        };
+
+        const next = this.stretches.map((stretch) => ({ from: map(stretch.from, false), to: map(stretch.to, true) }));
+        shift = 0;
+
+        for (const change of ordered) {
+            const from = change.from + shift;
+            next.push({ from, to: from + change.insertedLength });
+            shift += change.insertedLength - (change.to - change.from);
+        }
+
+        next.sort((left, right) => left.from - right.from);
+        this.stretches = [];
+
+        for (const stretch of next) {
+            const previous = this.stretches.at(-1);
+
+            if (previous !== undefined && stretch.from <= previous.to) {
+                previous.to = Math.max(previous.to, stretch.to);
+            } else {
+                this.stretches.push({ ...stretch });
+            }
+        }
+    }
+
+    /* The zero-based lines the stretches touch, in order. A stretch that ends at the start of a line, such as an inserted line, does not touch it. */
+    lines(lineAt: (offset: number) => number, lineStart: (line: number) => number): number[] {
+        const result: number[] = [];
+
+        for (const { from, to } of this.stretches) {
+            const first = lineAt(from);
+            let last = lineAt(to);
+
+            if (last > first && lineStart(last) === to) {
+                last--;
+            }
+
+            for (let line = Math.max(first, (result.at(-1) ?? -1) + 1); line <= last; line++) {
+                result.push(line);
+            }
+        }
+
+        return result;
+    }
+}