@adecore/editor-core 0.23.1 → 0.24.1

package/dist/document.js

@@ -12,6 +12,7 @@ import { lexicalFolds } from './lexical-folds.js';
 import { rangeOf, whitespaceOf } from './line-text.js';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.js';
 import { scanBrackets } from './brackets.js';
+import { BracketTracker } from './bracket-tracker.js';
 import { hasSmartSemicolon, isPhp } from './lexical.js';
 import { clampInteger, TextRope, ROPE_CHUNK_SIZE } from './rope.js';
 import { findMatches, findMatchFrom, replacementText, splitsSurrogate } from './search.js';
@@ -32,7 +33,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;
 function sameSelections(left, right) {
     return left.length === right.length && left.every((selection, index) => selection.anchor === right[index].anchor && selection.head === right[index].head);
 }
@@ -51,14 +52,35 @@ function selectionTransaction(plans) {
             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, offset) {
-    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. */
 function offsetIn(rope, value) {
@@ -85,6 +107,7 @@ function deletionStep(rope, offset, direction) {
     }
     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) {
@@ -98,33 +121,33 @@ function deletionStep(rope, offset, direction) {
     return direction < 0 ? previous : line.end;
 }
 /*
- * 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, selections) {
     const input = selections.length > 0 ? selections : [{ anchor: 0, head: 0 }];
-    const result = [];
-    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 };
-            }
-        }
-        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);
+    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 = [];
+    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 });
+        }
+    }
+    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) {
     let delta = 0;
@@ -182,6 +205,16 @@ function editsOf(rope, edits) {
  * either end, and is a little more than the change when two of them are far apart.
  */
 function stretchEdits(before, after, transactions) {
+    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, after, transactions) {
     let length = before.length;
     let prefix = Number.POSITIVE_INFINITY;
     let suffix = Number.POSITIVE_INFINITY;
@@ -195,15 +228,15 @@ function stretchEdits(before, after, transactions) {
         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. */
 function occurrenceSelection(match, shift) {
@@ -239,6 +272,7 @@ export class DocumentModel {
     occurrencesExhausted = false;
     closers = new CloserTracker();
     bracketCache;
+    bracketTracker = new BracketTracker(() => this.rope);
     scriptCache;
     constructor(text = '') {
         this.rope = TextRope.from(text);
@@ -266,6 +300,15 @@ export class DocumentModel {
     slice(from, to) {
         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, language = 'typescript', limit) {
+        return this.bracketTracker.match(offset, language, limit);
+    }
     getSelections() {
         return this.selections.map((selection) => ({ ...selection }));
     }
@@ -356,15 +399,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 &&
             this.groupOpen &&
@@ -1892,6 +1936,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;
@@ -1912,7 +1958,13 @@ 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/dist/index.d.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/dist/lexical.d.ts

@@ -13,4 +13,5 @@ export declare function indentsByBrackets(language: string): boolean;
 export declare function hasSmartSemicolon(language: string): boolean;
 export declare function isWordCharacter(character: string): boolean;
 export declare function startsExpression(word: string): boolean;
+export declare function startsExpressionAt(text: string, from: number, to: number): boolean;
 export declare function startsExpressionAfter(character: string): boolean;

package/dist/lexical.js

@@ -1,6 +1,8 @@
 export const openers = { '(': ')', '[': ']', '{': '}' };
 /* 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, at) {
     return at === 0 || /[\s;|&(]/.test(text[at - 1]);
@@ -63,12 +65,20 @@ export function hasSmartSemicolon(language) {
     return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|php)$/i.test(language);
 }
 export function isWordCharacter(character) {
+    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) {
-    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, from, to) {
+    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) {
-    return /[=,:;!?+\-*%&|^~<>]/.test(character);
+    return expressionPunctuation.has(character);
 }

package/dist/paste.js

@@ -37,7 +37,8 @@ function reindent(source, from, text, options) {
     const measured = widths.filter((width, index) => 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/dist/rope.js

@@ -1,16 +1,41 @@
 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, right) {
+    return left.endsWithCr && right.startsWithLf ? 1 : 0;
+}
 function leaf(text) {
     if (!text.length) {
         return null;
     }
     const breaks = [];
-    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, right) {
-    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, right) {
     if (left.height > right.height + 1 && 'left' in left) {
@@ -227,7 +252,7 @@ export class TextRope {
             }
             else {
                 offset -= node.left.length;
-                count += node.left.lines;
+                count += node.left.lines - sharedBreak(node.left, node.right);
                 node = node.right;
             }
         }
@@ -251,7 +276,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) {
         const bounds = this.lineBounds(index);
@@ -261,11 +287,12 @@ 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/dist/structure.js

@@ -103,7 +103,10 @@ export function deriveFoldingRanges(ranges, lineAt, lineCount, getLine, options
         }
     }
     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);

package/package.json

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