@adecore/editor-core 0.21.1 → 0.22.0

package/dist/markup-regions.js

@@ -175,7 +175,7 @@ class JsxScanner {
     /* An element from its `<`, recorded when no element holds it, and the offset after its closing tag; -1 when it is not one. */
     element(from, outermost) {
         this.depth++;
-        const end = this.parse(from);
+        const end = this.parseElement(from);
         this.depth--;
         if (end >= 0 && outermost && this.depth === 0) {
             this.ranges.push({ from, to: end });
@@ -189,7 +189,7 @@ class JsxScanner {
         }
         return at;
     }
-    parse(from) {
+    parseElement(from) {
         const { text } = this;
         let at = from + 1;
         while (at < text.length && NAME.test(text[at])) {
@@ -240,7 +240,7 @@ class JsxScanner {
                 at = this.code(at + 1, '}');
             }
             else if (value === '<' && START_OF_NAME.test(text[at + 1] ?? '')) {
-                at = this.parse(at);
+                at = this.parseElement(at);
             }
             else {
                 return -1;
@@ -264,7 +264,7 @@ class JsxScanner {
                 return closing !== null && closing[1] === name ? at + closing[0].length : -1;
             }
             else if (START_OF_NAME.test(text[at + 1] ?? '')) {
-                at = this.parse(at);
+                at = this.parseElement(at);
             }
             else {
                 return -1;
@@ -281,6 +281,25 @@ export function jsxRanges(text) {
     scanner.scan();
     return scanner.ranges;
 }
+/* Whether `offset` falls inside one of `ranges`, which are sorted and do not overlap. */
+function insideAny(ranges, offset) {
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const range = ranges[middle];
+        if (offset < range.from) {
+            high = middle - 1;
+        }
+        else if (offset >= range.to) {
+            low = middle + 1;
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
 /* Whether a language is one whose scripts can hold JSX. */
 export function hasJsx(language) {
     return JSX_LANGUAGES.test(language);
@@ -309,22 +328,7 @@ export function markupGuard(source, language) {
         return (line) => {
             const bounds = source.line(line);
             const start = bounds.start + (/^[\t ]*/.exec(bounds.text)?.[0].length ?? 0);
-            let low = 0;
-            let high = ranges.length - 1;
-            while (low <= high) {
-                const middle = (low + high) >> 1;
-                const range = ranges[middle];
-                if (start < range.from) {
-                    high = middle - 1;
-                }
-                else if (start >= range.to) {
-                    low = middle + 1;
-                }
-                else {
-                    return true;
-                }
-            }
-            return false;
+            return insideAny(ranges, start);
         };
     }
     return () => false;

package/dist/paste.js

@@ -1,11 +1,6 @@
+import { indentText, isBlank, whitespaceOf } from './line-text.js';
 import { mapOffset } from './offsets.js';
 import { indentationColumn } from './structure.js';
-function whitespaceOf(text) {
-    return /^[\t ]*/.exec(text)[0];
-}
-function isBlank(text) {
-    return text.trim() === '';
-}
 /* A line break at the end is the end of the last line, not a line of its own. */
 function linesOf(text) {
     return text.replace(/\r?\n$/, '').split(/\r?\n/);
@@ -18,12 +13,6 @@ function perCaretLines(text, carets) {
     const lines = linesOf(text);
     return lines.length === carets ? lines : null;
 }
-function indentText(width, options) {
-    if (options.insertSpaces) {
-        return ' '.repeat(width);
-    }
-    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
-}
 /*
  * Where a block of several lines lands, it lands at the indentation of the line it is pasted into:
  * the pasted lines move together by the difference between that indentation and the least indented

package/dist/preserve-case.js

@@ -21,41 +21,34 @@ export function replaceWithCaseRespect(replacement, found) {
     if (foundTail === '') {
         return head + replacementTail;
     }
-    let replacementLower = true;
-    let replacementUpper = true;
-    for (const character of replacementTail) {
-        if (!letter.test(character)) {
-            continue;
-        }
-        replacementLower &&= lower.test(character);
-        replacementUpper &&= upper.test(character);
-        if (!replacementLower && !replacementUpper) {
-            break;
-        }
+    const replacementCase = letterCase(replacementTail);
+    const foundCase = letterCase(foundTail);
+    // A tail without letters, like `x2`, follows the first letter of the match.
+    const tailUpper = foundCase.hasLetters ? foundCase.upper : upper.test(firstFound);
+    const tailLower = foundCase.hasLetters ? foundCase.lower : lower.test(firstFound);
+    if (tailUpper && (replacementCase.lower || !replacementCase.upper)) {
+        return head + replacementTail.toUpperCase();
+    }
+    if (tailLower && (replacementCase.lower || replacementCase.upper)) {
+        return head + replacementTail.toLowerCase();
     }
-    let tailUpper = true;
-    let tailLower = true;
-    let tailChecked = false;
-    for (const character of foundTail) {
+    return head + replacementTail;
+}
+/* Whether every letter of `text` is upper case and whether every one is lower case; both hold without letters. */
+function letterCase(text) {
+    let allUpper = true;
+    let allLower = true;
+    let hasLetters = false;
+    for (const character of text) {
         if (!letter.test(character)) {
             continue;
         }
-        tailUpper &&= upper.test(character);
-        tailLower &&= lower.test(character);
-        tailChecked = true;
-        if (!tailUpper && !tailLower) {
+        hasLetters = true;
+        allUpper &&= upper.test(character);
+        allLower &&= lower.test(character);
+        if (!allUpper && !allLower) {
             break;
         }
     }
-    if (!tailChecked) {
-        tailUpper = letter.test(firstFound) && upper.test(firstFound);
-        tailLower = letter.test(firstFound) && lower.test(firstFound);
-    }
-    if (tailUpper && (replacementLower || !replacementUpper)) {
-        return head + replacementTail.toUpperCase();
-    }
-    if (tailLower && (replacementLower || replacementUpper)) {
-        return head + replacementTail.toLowerCase();
-    }
-    return head + replacementTail;
+    return { upper: allUpper, lower: allLower, hasLetters };
 }

package/dist/structure.js

@@ -85,7 +85,7 @@ function indentationFolds(lineCount, getLine, tabSize, minimum) {
 }
 /* Ranges that span the same lines collapse into the first, which is the outermost. */
 export function deriveFoldingRanges(ranges, lineAt, lineCount, getLine, options = {}, slice) {
-    const minimum = options.minLines === undefined ? 1 : Math.max(1, Number.isFinite(options.minLines) ? Math.trunc(options.minLines) : 1);
+    const minimum = Number.isFinite(options.minLines) ? Math.max(1, Math.trunc(options.minLines)) : 1;
     const result = [];
     for (const range of ranges) {
         if (range.kind === 'string' || (range.kind === 'bracket' ? options.brackets === false : options.comments === false)) {

package/dist/typing-context.js

@@ -61,6 +61,11 @@ function scanLiteral(state, text, at, end, offset) {
     }
     return at;
 }
+function openComment(state, mode, start, resume) {
+    state.mode = mode;
+    state.commentStart = start;
+    return resume;
+}
 function scanCode(state, rules, text, at, end, offset) {
     const char = text[at];
     const next = text[at + 1];
@@ -68,29 +73,16 @@ function scanCode(state, rules, text, at, end, offset) {
         return at;
     }
     if (rules.markup && text.startsWith('<!--', at)) {
-        state.mode = 'html-comment';
-        state.commentStart = offset + at;
-        return at + 3;
+        return openComment(state, 'html-comment', offset + at, at + 3);
     }
     if (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at))) {
-        state.mode = 'line-comment';
-        state.commentStart = offset + at;
-        return at;
-    }
-    if (rules.dash && char === '-' && next === '-') {
-        state.mode = 'line-comment';
-        state.commentStart = offset + at;
-        return at + 1;
+        return openComment(state, 'line-comment', offset + at, at);
     }
-    if (rules.slash && char === '/' && next === '/') {
-        state.mode = 'line-comment';
-        state.commentStart = offset + at;
-        return at + 1;
+    if ((rules.dash && char === '-' && next === '-') || (rules.slash && char === '/' && next === '/')) {
+        return openComment(state, 'line-comment', offset + at, at + 1);
     }
     if (rules.block && char === '/' && next === '*') {
-        state.mode = 'block-comment';
-        state.commentStart = offset + at;
-        return at + 1;
+        return openComment(state, 'block-comment', offset + at, at + 1);
     }
     if (rules.php && char === '<' && text.startsWith('<<<', at)) {
         const opener = PHP_HEREDOC.exec(text.slice(at));

package/dist/words.js

@@ -5,6 +5,7 @@
 // `isLowerCaseOrDigit` and `isPunctuation` from JetBrains/intellij-community at
 // 7184b03af6c5370e79a01ded0df68cf56d7669da, platform/platform-impl/src/com/intellij/openapi/editor/actions/EditorActionUtil.java,
 // lines 934-982.
+import { splitsSurrogate } from './search.js';
 // Java's Character.isJavaIdentifierPart, which counts the ignorable control characters as part of a word.
 // oxlint-disable-next-line no-control-regex
 const identifierPart = /[\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mc}\p{Mn}\p{Cf}\u0000-\u0008\u000e-\u001b\u007f-\u009f]/u;
@@ -59,11 +60,8 @@ export function isWordBoundary(text, offset, camel, isStart) {
 export function wordBoundary(text, offset, direction, camel = true) {
     let position = offset + direction;
     while (position > 0 && position < text.length) {
-        const before = text.charAt(position - 1);
-        const after = text.charAt(position);
-        const splitsPair = /[\ud800-\udbff]/.test(before) && /[\udc00-\udfff]/.test(after);
-        const splitsLineBreak = before === '\r' && after === '\n';
-        if (!splitsPair && !splitsLineBreak && isWordBoundary(text, position, camel, direction === -1)) {
+        const splitsLineBreak = text.charAt(position - 1) === '\r' && text.charAt(position) === '\n';
+        if (!splitsSurrogate(text, position) && !splitsLineBreak && isWordBoundary(text, position, camel, direction === -1)) {
             return position;
         }
         position += direction;

package/package.json

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

package/src/block-folds.ts

@@ -15,16 +15,9 @@ const HEREDOC = /<<<[ \t]*(["']?)([A-Za-z_]\w*)\1\s*$/;
 function markdownFolds(lineCount: number, getLine: (line: number) => DocumentLine): FoldingRange[] {
     const result: FoldingRange[] = [];
     const headings: { line: number; level: number }[] = [];
-    let first = 0;
-    if (lineCount > 0 && getLine(0).text.trim() === '---') {
-        for (let line = 1; line < lineCount; line++) {
-            const text = getLine(line).text.trim();
-            if (text === '---' || text === '...') {
-                result.push(rangeOf(0, line, getLine, 'block', 'front-matter'));
-                first = line + 1;
-                break;
-            }
-        }
+    const frontMatter = frontMatterEnd(lineCount, getLine);
+    if (frontMatter !== -1) {
+        result.push(rangeOf(0, frontMatter, getLine, 'block', 'front-matter'));
     }
     let tableStart = -1;
     const flushTable = (end: number): void => {
@@ -33,19 +26,12 @@ function markdownFolds(lineCount: number, getLine: (line: number) => DocumentLin
         }
         tableStart = -1;
     };
-    for (let line = first; line < lineCount; line++) {
+    for (let line = frontMatter + 1; line < lineCount; line++) {
         const text = getLine(line).text;
         const fence = FENCE.exec(text);
         if (fence !== null) {
             flushTable(line - 1);
-            const marker = fence[1]!;
-            let end = -1;
-            for (let next = line + 1; next < lineCount && end === -1; next++) {
-                const closer = FENCE.exec(getLine(next).text);
-                if (closer !== null && closer[1]![0] === marker[0] && closer[1]!.length >= marker.length && getLine(next).text.trim() === closer[1]) {
-                    end = next;
-                }
-            }
+            const end = fenceEnd(line, fence[1]!, lineCount, getLine);
             if (end !== -1) {
                 result.push(rangeOf(line, end, getLine, 'block', 'code-fence'));
                 line = end;
@@ -76,6 +62,31 @@ function markdownFolds(lineCount: number, getLine: (line: number) => DocumentLin
     return result;
 }
 
+/* The line that closes front matter opened on the first line, or -1. */
+function frontMatterEnd(lineCount: number, getLine: (line: number) => DocumentLine): number {
+    if (lineCount === 0 || getLine(0).text.trim() !== '---') {
+        return -1;
+    }
+    for (let line = 1; line < lineCount; line++) {
+        const text = getLine(line).text.trim();
+        if (text === '---' || text === '...') {
+            return line;
+        }
+    }
+    return -1;
+}
+
+/* The line that closes a fence opened on `line` with `marker`, or -1. */
+function fenceEnd(line: number, marker: string, lineCount: number, getLine: (line: number) => DocumentLine): number {
+    for (let next = line + 1; next < lineCount; next++) {
+        const closer = FENCE.exec(getLine(next).text)?.[1];
+        if (closer !== undefined && closer[0] === marker[0] && closer.length >= marker.length && getLine(next).text.trim() === closer) {
+            return next;
+        }
+    }
+    return -1;
+}
+
 /* `<?php ... ?>` blocks that sit between markup, and heredocs and nowdocs. A block that opens the file is the file, not a fold. */
 function phpFolds(lineCount: number, getLine: (line: number) => DocumentLine): FoldingRange[] {
     const result: FoldingRange[] = [];

package/src/closer-tracker.ts

@@ -5,7 +5,7 @@ interface Mark {
     close: number;
 }
 
-const limit = 64;
+const maxMarks = 64;
 
 /*
  * The closers the editor inserted by itself and the caret has not left yet, which Tab steps over. A
@@ -17,7 +17,7 @@ export class CloserTracker {
 
     add(open: number, close: number): void {
         this.marks.push({ open, close });
-        if (this.marks.length > limit) {
+        if (this.marks.length > maxMarks) {
             this.marks.shift();
         }
     }

package/src/comments.ts

@@ -1,5 +1,6 @@
 import type { EditPlan, EditSource } from './edit-source.ts';
 import { type BlockComment, type CommentSyntax, commentSyntax } from './languages.ts';
+import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.ts';
 import { mapOffset } from './offsets.ts';
 import { indentationColumn } from './structure.ts';
 import type { Selection, TextEdit } from './types.ts';
@@ -26,23 +27,11 @@ interface Geometry {
     length: number;
 }
 
-function whitespaceOf(text: string): string {
-    return /^[\t ]*/.exec(text)![0];
-}
-
-function isBlank(text: string): boolean {
-    return text.trim() === '';
-}
-
 function syntaxOf(source: EditSource, options: CommentOptions, line: number): CommentSyntax {
     const syntax = commentSyntax(options.language, source.region(line));
     return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
 }
 
-function rangeOf(selection: Selection): { from: number; to: number } {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
-
 /* The runs of adjacent lines the selections touch. A selection that ends at the start of a line does not touch it. */
 function blocksOf(source: EditSource, selections: readonly Selection[], span?: CommentOptions['lineSpan']): Block[] {
     const blocks: Block[] = [];
@@ -80,13 +69,6 @@ function isCommented(text: string, syntax: CommentSyntax, multiline: boolean): b
     return trimmed.length >= block.open.length + block.close.length && trimmed.startsWith(block.open) && trimmed.endsWith(block.close);
 }
 
-function indentText(width: number, options: CommentOptions): string {
-    if (options.insertSpaces) {
-        return ' '.repeat(width);
-    }
-    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
-}
-
 /* The new place of a line after the edits, which never cross a line break. */
 function geometryOf(source: EditSource, edits: readonly TextEdit[], index: number): Geometry {
     const bounds = source.line(index);
@@ -162,14 +144,20 @@ export function planLineComments(source: EditSource, selections: readonly Select
     return { edits, selections: finalSelections(source, selections, blocks, edits, allCommented, placed, lineBased, options.lineSpan) };
 }
 
-function minimumIndent(source: EditSource, block: Block, syntax: CommentSyntax, options: CommentOptions): number {
+/* The indentation of the least indented non-blank line, infinite when every line is blank. */
+function smallestIndent(source: EditSource, first: number, last: number, tabSize: number): number {
     let minimum = Number.POSITIVE_INFINITY;
-    for (let line = block.first; line <= block.last; line++) {
+    for (let line = first; line <= last; line++) {
         const text = source.line(line).text;
         if (!isBlank(text)) {
-            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
+            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), tabSize));
         }
     }
+    return minimum;
+}
+
+function minimumIndent(source: EditSource, block: Block, syntax: CommentSyntax, options: CommentOptions): number {
+    let minimum = smallestIndent(source, block.first, block.last, options.tabSize);
     if (block.first > 0) {
         const previous = source.line(block.first - 1).text;
         const marker = syntax.line ?? syntax.block?.open;
@@ -394,13 +382,7 @@ function wrapRange(source: EditSource, from: number, to: number, block: BlockCom
             { from: to, to, text: ` ${block.close}` }
         ];
     }
-    let minimum = Number.POSITIVE_INFINITY;
-    for (let line = first; line <= last; line++) {
-        const text = source.line(line).text;
-        if (!isBlank(text)) {
-            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
-        }
-    }
+    const minimum = smallestIndent(source, first, last, options.tabSize);
     const space = indentText(Number.isFinite(minimum) ? minimum : 0, options);
     const newline = source.newline(first);
     const closing = source.charAt(to - 1) === '\n' ? `${space}${block.close}${newline}` : `${newline}${space}${block.close}`;

package/src/document.ts

@@ -10,6 +10,7 @@ import { isPlainText, vueRegionAt } from './languages.ts';
 import { blockFolds } from './block-folds.ts';
 import { applyFoldHints, markFileHeader } from './fold-roles.ts';
 import { lexicalFolds } from './lexical-folds.ts';
+import { rangeOf, whitespaceOf } from './line-text.ts';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.ts';
 import { scanBrackets } from './brackets.ts';
 import type { BracketIndex } from './brackets.ts';
@@ -38,7 +39,6 @@ import { isHumpBoundary, isWordBoundary } from './words.ts';
 
 export type { DocumentLine, FindMatch, FindNextOptions, FindOptions, FoldingOptions, FoldingRange };
 
-/* A stretch of the text by offsets. */
 export interface OffsetRange {
     readonly from: number;
     readonly to: number;
@@ -154,18 +154,10 @@ const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
 const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
-function rangeOf(selection: Selection): { from: number; to: number } {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
-
 function sameSelections(left: readonly Selection[], right: readonly Selection[]): boolean {
     return left.length === right.length && left.every((selection, index) => selection.anchor === right[index]!.anchor && selection.head === right[index]!.head);
 }
 
-function indentLength(text: string): number {
-    return text.match(/^[\t ]*/)?.[0].length ?? 0;
-}
-
 function trailingBlankLength(text: string): number {
     return text.match(/[\t ]*$/)?.[0].length ?? 0;
 }
@@ -274,13 +266,13 @@ function inverseChanges(changes: readonly DocumentChange[]): DocumentChange[] {
     });
 }
 
-/* Runs of consecutive line numbers, from a sorted list. */
 type LineSpanOf = NonNullable<CommandOptions['lineSpan']>;
 
 function range(first: number, last: number): number[] {
     return Array.from({ length: last - first + 1 }, (_, index) => first + index);
 }
 
+/* Runs of consecutive line numbers, from a sorted list. */
 function blocks(indices: readonly number[]): LineBlock[] {
     const result: LineBlock[] = [];
     for (const index of indices) {
@@ -313,7 +305,8 @@ function indentStopLength(prefix: string, tabSize: number): number {
 
 function positionIn(rope: TextRope, offset: number): Position {
     const line = rope.lineAt(offset);
-    return { line, column: Math.min(offset, rope.lineBounds(line).end) - rope.lineBounds(line).start };
+    const bounds = rope.lineBounds(line);
+    return { line, column: Math.min(offset, bounds.end) - bounds.start };
 }
 
 /* Simultaneous edits of `rope` as a sequence, last to first, so each edit's position in `rope` is also its position once the ones after it are applied. */
@@ -351,6 +344,15 @@ function stretchEdits(before: TextRope, after: TextRope, transactions: readonly
     return [{ start: positionIn(before, prefix), end: positionIn(before, oldEnd), text: after.slice(prefix, newEnd) }];
 }
 
+/* An occurrence selected with its caret `shift` characters into it, as the caret stood in the selection it repeats. */
+function occurrenceSelection(match: OffsetRange, shift: number): Selection {
+    if (shift === 0) {
+        return { anchor: match.to, head: match.from };
+    }
+    const caret = Math.min(match.from + shift, match.to);
+    return { anchor: caret === match.to ? match.from : match.to, head: caret };
+}
+
 /*
  * Text with a selection, undo history and the editing commands of a code editor, and no idea how it
  * is drawn. Offsets are UTF-16 code units, lines and columns zero-based. The text is a persistent
@@ -557,10 +559,7 @@ export class DocumentModel {
     }
 
     positionAt(offset: number): Position {
-        const clamped = offsetIn(this.rope, offset);
-        const line = this.rope.lineAt(clamped);
-        const bounds = this.rope.lineBounds(line);
-        return { line, column: Math.min(clamped, bounds.end) - bounds.start };
+        return positionIn(this.rope, offsetIn(this.rope, offset));
     }
 
     /* A column past the end of its line lands on the end of the line, before the line break. */
@@ -930,7 +929,7 @@ export class DocumentModel {
         if (!/^[\t ]*$/.test(before)) {
             return null;
         }
-        const indent = this.getLine(this.rope.lineAt(opener)).text.match(/^[\t ]*/)?.[0] ?? '';
+        const indent = whitespaceOf(this.getLine(this.rope.lineAt(opener)).text);
         if (indent === before) {
             return null;
         }
@@ -1341,16 +1340,11 @@ export class DocumentModel {
         return plan !== null && this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
     }
 
-    /* The lines the carets and selections touch. A selection that ends at the start of a line does not touch it. */
+    /* The lines the carets and selections touch, sorted. */
     private selectedLines(span?: LineSpanOf): number[] {
         const indices = new Set<number>();
         for (const selection of this.selections) {
-            const { from, to } = rangeOf(selection);
-            let first = this.rope.lineAt(from);
-            let last = this.rope.lineAt(to);
-            if (to > from && this.rope.lineBounds(last).start === to) {
-                last--;
-            }
+            let { first, last } = this.touchedLines(selection);
             if (span) {
                 first = span(first).first;
                 last = Math.max(last, span(last).last);
@@ -1362,6 +1356,14 @@ export class DocumentModel {
         return [...indices].sort((left, right) => left - right);
     }
 
+    /* The lines a selection touches; one that ends at the start of a line does not touch it. */
+    private touchedLines(selection: Selection): LineBlock {
+        const { from, to } = rangeOf(selection);
+        const first = this.rope.lineAt(from);
+        const last = this.rope.lineAt(to);
+        return { first, last: last > first && this.rope.lineBounds(last).start === to ? last - 1 : last };
+    }
+
     /* A selection is copied in place, its copy selected; a caret duplicates its line and moves down with it. */
     private duplicate(span?: LineSpanOf): boolean {
         const carets = this.selections.filter((selection) => selection.anchor === selection.head);
@@ -1542,7 +1544,7 @@ export class DocumentModel {
                 const index = this.rope.lineAt(selection.head);
                 const line = this.rope.lineBounds(index);
                 const text = this.getLine(index).text;
-                const indent = (text.match(/^[\t ]*/)?.[0] ?? '') + (/^[\t ]*[)\]}]/.test(text) ? unit : '');
+                const indent = whitespaceOf(text) + (/^[\t ]*[)\]}]/.test(text) ? unit : '');
                 return { from: line.start, to: line.start, text: indent + this.newlineAt(index), anchor: indent.length, head: indent.length };
             }),
             { source: 'command' }
@@ -1601,7 +1603,7 @@ export class DocumentModel {
             return true;
         }
         const closer = index.pairs.get(offset);
-        const indentAt = (at: number): number => this.getLine(this.rope.lineAt(at)).text.match(/^[\t ]*/)![0].length;
+        const indentAt = (at: number): number => whitespaceOf(this.getLine(this.rope.lineAt(at)).text).length;
         if (closer === undefined || indentAt(closer) >= indentAt(offset)) {
             return false;
         }
@@ -1958,7 +1960,7 @@ export class DocumentModel {
             { from: 0, to: this.rope.length }
         ];
         if (first.start === last.start) {
-            candidates.push({ from: first.start + indentLength(first.text), to: first.end - trailingBlankLength(first.text) });
+            candidates.push({ from: first.start + whitespaceOf(first.text).length, to: first.end - trailingBlankLength(first.text) });
         }
         for (const range of this.structure()) {
             candidates.push({ from: range.innerFrom, to: range.innerTo }, range);
@@ -2033,10 +2035,7 @@ export class DocumentModel {
             this.rememberOccurrence(wholeWord, notFoundBefore);
             return false;
         }
-        const shift = primary.head - from;
-        const caret = Math.min(match.from + shift, match.to);
-        const added = shift === 0 ? { anchor: match.to, head: match.from } : { anchor: caret === match.to ? match.from : match.to, head: caret };
-        const changed = this.changeSelections([...this.selections, added]);
+        const changed = this.changeSelections([...this.selections, occurrenceSelection(match, primary.head - from)]);
         this.rememberOccurrence(wholeWord, false);
         return changed;
     }
@@ -2071,12 +2070,7 @@ export class DocumentModel {
         if (matches.length === 0) {
             return false;
         }
-        const changed = this.changeSelections(
-            matches.map((match) => {
-                const caret = Math.min(match.from + shift, match.to);
-                return shift === 0 ? { anchor: match.to, head: match.from } : { anchor: caret === match.to ? match.from : match.to, head: caret };
-            })
-        );
+        const changed = this.changeSelections(matches.map((match) => occurrenceSelection(match, shift)));
         this.rememberOccurrence(wholeWord, false);
         return changed;
     }
@@ -2086,12 +2080,7 @@ export class DocumentModel {
         const forward = this.selections.at(-1)!.head >= this.selections.at(-1)!.anchor;
         const carets: Selection[] = [];
         for (const selection of this.selections) {
-            const { from, to } = rangeOf(selection);
-            const first = this.rope.lineAt(from);
-            let last = this.rope.lineAt(to);
-            if (last > first && to === this.rope.lineBounds(last).start) {
-                last--;
-            }
+            const { first, last } = this.touchedLines(selection);
             for (let line = first; line <= last; line++) {
                 const end = this.rope.lineBounds(line).end;
                 carets.push({ anchor: end, head: end });