@adecore/editor-core 0.23.1 → 0.24.0

package/src/document.ts

@@ -14,7 +14,8 @@ 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';
+import type { BracketIndex, BracketMatch } from './brackets.ts';
+import { BracketTracker } from './bracket-tracker.ts';
 import { hasSmartSemicolon, isPhp } from './lexical.ts';
 import { clampInteger, TextRope, ROPE_CHUNK_SIZE } from './rope.ts';
 import type { DocumentLine } from './rope.ts';
@@ -155,7 +156,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 graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+let graphemes: Intl.Segmenter | undefined;
 
 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);
@@ -178,15 +179,35 @@ function selectionTransaction(plans: readonly SelectionEdit[]): SelectionTransac
             edits.push(plan);
         }
     }
+    // What the edits before each one add to the text, so a caret finds its shift by a binary search.
+    const shifts = [0];
+    for (const edit of edits) {
+        shifts.push(shifts.at(-1)! + edit.text.length - (edit.to - edit.from));
+    }
     const selections = plans.map((plan) => {
-        const delta = edits.filter((edit) => edit.from < plan.from).reduce((sum, edit) => sum + edit.text.length - (edit.to - edit.from), 0);
+        let low = 0;
+        let high = edits.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (edits[middle]!.from < plan.from) {
+                low = middle + 1;
+            } else {
+                high = middle;
+            }
+        }
+        const delta = shifts[low]!;
         return { anchor: plan.from + delta + plan.anchor, head: plan.from + delta + plan.head };
     });
     return { edits, selections };
 }
 
 function splitsCluster(rope: TextRope, offset: number): boolean {
-    return splitsSurrogate(rope, offset) || (rope.charAt(offset - 1) === '\r' && rope.charAt(offset) === '\n');
+    const before = rope.charAt(offset - 1);
+    // One read of the rope settles most offsets, which follow neither a `\r` nor the first half of a surrogate pair.
+    if (before === '\r') {
+        return rope.charAt(offset) === '\n';
+    }
+    return /[\ud800-\udbff]/.test(before) && splitsSurrogate(rope, offset);
 }
 
 /* Clamps to the document and moves back off the middle of a surrogate pair or a CRLF. */
@@ -217,6 +238,7 @@ function deletionStep(rope: TextRope, offset: number, direction: -1 | 1): number
     }
     const line = rope.getLine(rope.lineAt(offset));
     let previous = line.start;
+    graphemes ??= new Intl.Segmenter(undefined, { granularity: 'grapheme' });
     for (const segment of graphemes.segment(line.text)) {
         const at = line.start + segment.index;
         if (direction < 0 && at >= offset) {
@@ -231,33 +253,32 @@ function deletionStep(rope: TextRope, offset: number, direction: -1 | 1): number
 }
 
 /*
- * Clamps every selection and merges the ones that overlap or touch, so the result is disjoint. The
- * last one stays the primary caret, and a merge that takes it in keeps it last.
+ * Clamps every selection and merges the ones that overlap or touch, so the result is disjoint. A merged
+ * selection takes the place and the direction of the last added of the ones it holds, so the primary caret stays last.
  */
 function normalizeSelections(rope: TextRope, selections: readonly Selection[]): Selection[] {
     const input = selections.length > 0 ? selections : [{ anchor: 0, head: 0 }];
-    const result: { selection: Selection; primary: boolean }[] = [];
-    for (const [position, raw] of input.entries()) {
-        let selection = { anchor: offsetIn(rope, raw.anchor), head: offsetIn(rope, raw.head) };
-        let primary = position === input.length - 1;
-        let { from, to } = rangeOf(selection);
-        for (let index = result.length - 1; index >= 0; index--) {
-            const other = rangeOf(result[index]!.selection);
-            if (from <= other.to && to >= other.from) {
-                from = Math.min(from, other.from);
-                to = Math.max(to, other.to);
-                primary ||= result[index]!.primary;
-                result.splice(index, 1);
-                selection = selection.anchor > selection.head ? { anchor: to, head: from } : { anchor: from, head: to };
-            }
+    const clamped = input.map((raw) => {
+        const anchor = offsetIn(rope, raw.anchor);
+        return { anchor, head: raw.head === raw.anchor ? anchor : offsetIn(rope, raw.head) };
+    });
+    const order = clamped.map((selection, index) => ({ ...rangeOf(selection), index })).sort((left, right) => left.from - right.from);
+    const groups: { from: number; to: number; last: number }[] = [];
+    for (const { from, to, index } of order) {
+        const group = groups.at(-1);
+        if (group !== undefined && from <= group.to) {
+            group.to = Math.max(group.to, to);
+            group.last = Math.max(group.last, index);
+        } else {
+            groups.push({ from, to, last: index });
         }
-        result.push({ selection, primary });
-    }
-    const primary = result.findIndex((entry) => entry.primary);
-    if (primary !== result.length - 1) {
-        result.push(...result.splice(primary, 1));
     }
-    return result.map((entry) => entry.selection);
+    return groups
+        .sort((left, right) => left.last - right.last)
+        .map((group) => {
+            const selection = clamped[group.last]!;
+            return selection.anchor > selection.head ? { anchor: group.to, head: group.from } : { anchor: group.from, head: group.to };
+        });
 }
 
 function inverseChanges(changes: readonly DocumentChange[]): DocumentChange[] {
@@ -323,6 +344,17 @@ function editsOf(rope: TextRope, edits: readonly TextEdit[]): ContentEdit[] {
  * either end, and is a little more than the change when two of them are far apart.
  */
 function stretchEdits(before: TextRope, after: TextRope, transactions: readonly (readonly DocumentChange[])[]): ContentEdit[] {
+    const stretch = stretchOf(before, after, transactions);
+    if (stretch === undefined) {
+        return [];
+    }
+    return [
+        { start: positionIn(before, stretch.from), end: positionIn(before, stretch.to), text: after.slice(stretch.from, stretch.from + stretch.insertedLength) }
+    ];
+}
+
+/* The one change in the coordinates of `before` that holds every change of the transactions, or undefined when they change nothing. */
+function stretchOf(before: TextRope, after: TextRope, transactions: readonly (readonly DocumentChange[])[]): DocumentChange | undefined {
     let length = before.length;
     let prefix = Number.POSITIVE_INFINITY;
     let suffix = Number.POSITIVE_INFINITY;
@@ -336,15 +368,15 @@ function stretchEdits(before: TextRope, after: TextRope, transactions: readonly
         length += delta;
     }
     if (!Number.isFinite(prefix)) {
-        return [];
+        return undefined;
     }
     const kept = Math.min(Math.max(0, suffix), before.length - prefix, after.length - prefix);
     const oldEnd = before.length - kept;
     const newEnd = after.length - kept;
     if (oldEnd === prefix && newEnd === prefix) {
-        return [];
+        return undefined;
     }
-    return [{ start: positionIn(before, prefix), end: positionIn(before, oldEnd), text: after.slice(prefix, newEnd) }];
+    return { from: prefix, to: oldEnd, insertedLength: newEnd - prefix };
 }
 
 /* An occurrence selected with its caret `shift` characters into it, as the caret stood in the selection it repeats. */
@@ -382,6 +414,7 @@ export class DocumentModel {
     occurrencesExhausted = false;
     private closers = new CloserTracker();
     private bracketCache?: { revision: number; language: string; index: BracketIndex };
+    private bracketTracker = new BracketTracker(() => this.rope);
     private scriptCache?: { revision: number; sources: Map<number, { limit: number; text?: string; index?: BracketIndex }> };
 
     constructor(text = '') {
@@ -417,6 +450,16 @@ export class DocumentModel {
         return this.rope.slice(from, to);
     }
 
+    /*
+     * Where the bracket at `offset` pairs, as `scanBrackets` pairs it, with no mate for one it leaves unmatched.
+     * Undefined where no bracket of the code stands, such as in a string or a comment. An edit lexes only the few
+     * kilobytes around it again, so this stays cheap on every keystroke of a large document. With `limit` it lexes
+     * at most about that many characters and returns null when that was not enough; asking again goes on from there.
+     */
+    matchBracket(offset: number, language = 'typescript', limit?: number): BracketMatch | null | undefined {
+        return this.bracketTracker.match(offset, language, limit);
+    }
+
     getSelections(): readonly Selection[] {
         return this.selections.map((selection) => ({ ...selection }));
     }
@@ -516,15 +559,16 @@ export class DocumentModel {
         const before = this.state();
         const firstLine = this.rope.lineAt(changed[0]!.from);
         const previous = this.rope;
+        const changes = changed.map((edit) => ({ from: edit.from, to: edit.to, insertedLength: edit.text.length }));
         this.rope = next;
         this.invalidate();
         this.typingContexts.invalidate(firstLine);
+        this.bracketTracker.edited(previous, next, changes);
         this.selections = normalizeSelections(this.rope, nextSelections);
         this.closers.map(changed);
         this.closers.prune(this.selections);
         this.revision++;
         const after = this.state();
-        const changes = changed.map((edit) => ({ from: edit.from, to: edit.to, insertedLength: edit.text.length }));
         const last = this.undoStack.at(-1);
         const joinsGroup =
             options.historyGroup &&
@@ -2211,6 +2255,8 @@ export class DocumentModel {
         this.invalidate();
         this.closers.clear();
         this.typingContexts.invalidate();
+        const stretch = stretchOf(previous, state.rope, changes);
+        this.bracketTracker.edited(previous, state.rope, stretch === undefined ? [] : [stretch]);
         this.selections = state.selections.map((selection) => ({ ...selection }));
         this.revision++;
         this.groupOpen = false;
@@ -2237,7 +2283,12 @@ export class DocumentModel {
             }
         }
         for (const listener of this.listeners) {
-            listener(snapshot);
+            try {
+                listener(snapshot);
+            } catch (error) {
+                // The text has changed by now, so a failing listener must not throw at the caller or keep the others, such as a language server's sync, from hearing it.
+                console.error('A document listener failed.', error);
+            }
         }
     }
 }

package/src/index.ts

@@ -1,6 +1,6 @@
 export { DocumentModel } from './document.ts';
 export type { DocumentEditOptions, DocumentLine, OffsetRange, ReplaceAllOptions, ReplaceOptions, TypeTextOptions } from './document.ts';
-export { scanBrackets, type BracketIndex } from './brackets.ts';
+export { scanBrackets, type BracketIndex, type BracketMatch } from './brackets.ts';
 export { replaceWithCaseRespect } from './preserve-case.ts';
 export { findMatches, iterateMatches, findMatchFrom, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
 export { indentationColumn } from './structure.ts';

package/src/lexical.ts

@@ -1,7 +1,9 @@
 export const openers: Readonly<Record<string, string>> = { '(': ')', '[': ']', '{': '}' };
 
 /* Words after which a `/` starts a regex and a `{` an object or a block, not a division or a statement end. */
-const expressionWords = /^(return|throw|case|yield|await|new|delete|typeof|void|in|of|instanceof)$/;
+const expressionWords = new Set(['return', 'throw', 'case', 'yield', 'await', 'new', 'delete', 'typeof', 'void', 'in', 'of', 'instanceof']);
+const expressionInitials = new Set([...expressionWords].map((word) => word[0]));
+const expressionPunctuation = new Set('=,:;!?+-*%&|^~<>');
 
 /* Whether a `#` at this index stands where a word would start, after whitespace, a separator or an opener. */
 export function startsWord(text: string, at: number): boolean {
@@ -100,14 +102,23 @@ export function hasSmartSemicolon(language: string): boolean {
 }
 
 export function isWordCharacter(character: string): boolean {
+    const code = character.charCodeAt(0);
+    if (code < 128) {
+        return (code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code === 95 || code === 36;
+    }
     return /[\p{L}\p{N}_$]/u.test(character);
 }
 
 export function startsExpression(word: string): boolean {
-    return expressionWords.test(word);
+    return expressionWords.has(word);
+}
+
+/* `startsExpression` for the word from `from` to `to` in `text`, which cuts the word out only when it could be one. */
+export function startsExpressionAt(text: string, from: number, to: number): boolean {
+    return to - from >= 2 && to - from <= 10 && expressionInitials.has(text[from]!) && expressionWords.has(text.slice(from, to));
 }
 
 /* Whether what follows a punctuation character is an expression, so a `/` there is a regex. */
 export function startsExpressionAfter(character: string): boolean {
-    return /[=,:;!?+\-*%&|^~<>]/.test(character);
+    return expressionPunctuation.has(character);
 }

package/src/paste.ts

@@ -51,7 +51,8 @@ function reindent(source: EditSource, from: number, text: string, options: Paste
     const measured = widths.filter((width, index): width is number => width !== null && !(anchored && index === 0));
     const trailingBreak = isBlank(lines.at(-1)!);
     if (measured.length > 0) {
-        const delta = target - Math.min(...measured);
+        // A reduce, not a spread: a paste of a few hundred thousand lines is more arguments than V8 takes in one call.
+        const delta = target - measured.reduce((least, width) => Math.min(least, width));
         for (const [index, entry] of lines.entries()) {
             const width = widths[index];
             if (width === null || width === undefined || (anchored && index === 0)) {

package/src/rope.ts

@@ -8,27 +8,56 @@ export interface DocumentLine {
 
 /*
  * A persistent AVL tree of text chunks of at most `ROPE_CHUNK_SIZE` UTF-16 code units. Every node knows
- * its length and its LF count, a leaf also where its LFs are, so offsets and line numbers resolve
- * without scanning.
+ * its length and its line break count, a leaf also where its breaks are, so offsets and line numbers
+ * resolve without scanning. A line ends at `\n`, `\r\n` or a lone `\r`, as the language server protocol
+ * counts lines, and a break sits at the last code unit of its line ending.
  */
-type Leaf = { readonly text: string; readonly breaks: readonly number[]; readonly length: number; readonly lines: number; readonly height: number };
-type Branch = { readonly left: Node; readonly right: Node; readonly length: number; readonly lines: number; readonly height: number };
+type Edges = { readonly startsWithLf: boolean; readonly endsWithCr: boolean };
+type Leaf = Edges & { readonly text: string; readonly breaks: readonly number[]; readonly length: number; readonly lines: number; readonly height: number };
+type Branch = Edges & { readonly left: Node; readonly right: Node; readonly length: number; readonly lines: number; readonly height: number };
 type Node = Leaf | Branch;
 export const ROPE_CHUNK_SIZE = 2048;
 
+const CR = 13;
+const LF = 10;
+
+/* A node counts a `\r` it ends with as a break; when the next node starts with `\n`, the two are one CRLF and only the `\n` is. */
+function sharedBreak(left: Node, right: Node): number {
+    return left.endsWithCr && right.startsWithLf ? 1 : 0;
+}
+
 function leaf(text: string): Leaf | null {
     if (!text.length) {
         return null;
     }
     const breaks: number[] = [];
-    for (let index = text.indexOf('\n'); index !== -1; index = text.indexOf('\n', index + 1)) {
-        breaks.push(index);
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if (code === LF || (code === CR && text.charCodeAt(index + 1) !== LF)) {
+            breaks.push(index);
+        }
     }
-    return { text, breaks, length: text.length, lines: breaks.length, height: 1 };
+    return {
+        text,
+        breaks,
+        length: text.length,
+        lines: breaks.length,
+        height: 1,
+        startsWithLf: text.charCodeAt(0) === LF,
+        endsWithCr: text.charCodeAt(text.length - 1) === CR
+    };
 }
 
 function branch(left: Node, right: Node): Branch {
-    return { left, right, length: left.length + right.length, lines: left.lines + right.lines, height: Math.max(left.height, right.height) + 1 };
+    return {
+        left,
+        right,
+        length: left.length + right.length,
+        lines: left.lines + right.lines - sharedBreak(left, right),
+        height: Math.max(left.height, right.height) + 1,
+        startsWithLf: left.startsWithLf,
+        endsWithCr: right.endsWithCr
+    };
 }
 
 function balance(left: Node, right: Node): Node {
@@ -259,7 +288,7 @@ export class TextRope {
                 node = node.left;
             } else {
                 offset -= node.left.length;
-                count += node.left.lines;
+                count += node.left.lines - sharedBreak(node.left, node.right);
                 node = node.right;
             }
         }
@@ -283,7 +312,8 @@ export class TextRope {
             return { start, end: this.length, next: this.length };
         }
         const newline = this.breakAt(index);
-        return { start, end: newline - (this.charAt(newline - 1) === '\r' ? 1 : 0), next: newline + 1 };
+        const crlf = this.charAt(newline) === '\n' && this.charAt(newline - 1) === '\r';
+        return { start, end: newline - (crlf ? 1 : 0), next: newline + 1 };
     }
 
     getLine(index: number): DocumentLine {
@@ -295,10 +325,11 @@ export class TextRope {
         let node = this.root!;
         let offset = 0;
         while ('left' in node) {
-            if (index < node.left.lines) {
+            const leftLines = node.left.lines - sharedBreak(node.left, node.right);
+            if (index < leftLines) {
                 node = node.left;
             } else {
-                index -= node.left.lines;
+                index -= leftLines;
                 offset += node.left.length;
                 node = node.right;
             }

package/src/structure.ts

@@ -207,7 +207,10 @@ export function deriveFoldingRanges(
         }
     }
     if (options.indentation) {
-        result.push(...indentationFolds(lineCount, getLine, tabWidth(options), minimum));
+        // One push per fold: a long file has more of them than V8 takes as arguments in one call.
+        for (const fold of indentationFolds(lineCount, getLine, tabWidth(options), minimum)) {
+            result.push(fold);
+        }
     }
     result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
     return dedupeFoldingRanges(result);