@adecore/editor-core 0.23.1 → 0.24.0

package/dist/bracket-tracker.d.ts

@@ -0,0 +1,25 @@
+import { type BracketMatch } from './brackets.ts';
+import type { TextRope } from './rope.ts';
+import type { DocumentChange } from './types.ts';
+export type BracketText = Pick<TextRope, 'length' | 'lineCount' | 'charAt' | 'lineAt' | 'lineBounds' | 'slice'>;
+export declare class BracketTracker {
+    private readonly text;
+    private readonly stretchLength;
+    private language;
+    private rules;
+    private checkpoints;
+    private proven;
+    private budget;
+    constructor(text: () => BracketText, stretchLength?: number);
+    edited(before: BracketText, after: BracketText, changes: readonly DocumentChange[]): void;
+    match(offset: number, language: string, limit?: number): BracketMatch | null | undefined;
+    private use;
+    private nextStale;
+    private prove;
+    private relex;
+    private stretchOf;
+    private lexStretch;
+    private eventAt;
+    private closerAfter;
+    private openerBefore;
+}

package/dist/bracket-tracker.js

@@ -0,0 +1,272 @@
+import { bracketRules, initialBracketState, lexBrackets, sameBracketState } from './brackets.js';
+/* How much text one stretch between checkpoints holds, which is what an edit makes the tracker lex again. */
+const STRETCH_LENGTH = 4096;
+const IGNORE = {
+    open() { },
+    close() { },
+    mismatch() { }
+};
+/*
+ * Pairs the bracket at an offset without lexing the document for it. The lexer's state is kept at checkpoints a
+ * few kilobytes apart, so an edit lexes only the stretch it is in, and the checkpoints after it count again as
+ * soon as the state at one of them comes out the same. Each checkpoint also knows how few brackets were open
+ * until the next, which lets a search for a far mate step over whole stretches.
+ */
+export class BracketTracker {
+    text;
+    stretchLength;
+    language = '';
+    rules = bracketRules('');
+    checkpoints = [];
+    /* The first stale checkpoint: what comes before it is proven, and so is its state. */
+    proven = 0;
+    /* How much more the current question may lex. */
+    budget = Number.POSITIVE_INFINITY;
+    constructor(text, stretchLength = STRETCH_LENGTH) {
+        this.text = text;
+        this.stretchLength = stretchLength;
+    }
+    /* Follows simultaneous changes that turned `before` into `after`, in the coordinates of `before`. */
+    edited(before, after, changes) {
+        if (this.checkpoints.length === 0 || changes.length === 0) {
+            return;
+        }
+        const edits = [];
+        let delta = 0;
+        for (const change of changes) {
+            // The line above too, since an edit at the start of a line can turn the `\r` that ends it into a `\r\n`.
+            const first = Math.max(0, before.lineAt(change.from) - 1);
+            const oldLast = before.lineAt(change.to);
+            const newLast = after.lineAt(change.from + delta + change.insertedLength);
+            delta += change.insertedLength - (change.to - change.from);
+            const previous = edits.at(-1);
+            if (previous !== undefined && first <= previous.oldLast) {
+                previous.oldLast = oldLast;
+                previous.newLast = newLast;
+            }
+            else {
+                edits.push({ first, oldLast, newLast });
+            }
+        }
+        const kept = [];
+        let index = 0;
+        let shift = 0;
+        for (const checkpoint of this.checkpoints) {
+            let dropped = false;
+            while (index < edits.length && checkpoint.line > edits[index].first) {
+                kept.at(-1).stale = true;
+                if (checkpoint.line <= edits[index].oldLast) {
+                    dropped = true;
+                    break;
+                }
+                shift = edits[index].newLast - edits[index].oldLast;
+                index++;
+            }
+            if (!dropped) {
+                checkpoint.line += shift;
+                kept.push(checkpoint);
+            }
+        }
+        if (index < edits.length) {
+            kept.at(-1).stale = true;
+        }
+        this.checkpoints = kept;
+        this.proven = this.nextStale(0);
+    }
+    /*
+     * The mate of the bracket at `offset`. Undefined where no bracket of the code stands, as in a string or a comment,
+     * and null when answering takes lexing more than `limit` characters; the work is kept, so asking again goes on.
+     */
+    match(offset, language, limit = Number.POSITIVE_INFINITY) {
+        const rope = this.text();
+        if (!/^[()[\]{}]$/.test(rope.charAt(offset))) {
+            return undefined;
+        }
+        this.use(language);
+        this.budget = limit;
+        const line = rope.lineAt(offset);
+        if (!this.prove(line)) {
+            return null;
+        }
+        const index = this.stretchOf(line);
+        const event = this.eventAt(index, offset);
+        if (event === undefined) {
+            return undefined;
+        }
+        if (event.kind === 'mismatch' || event.mate === null) {
+            return { mate: undefined };
+        }
+        if (event.mate !== undefined) {
+            return { mate: event.mate };
+        }
+        const mate = event.kind === 'open' ? this.closerAfter(index, event.depth) : this.openerBefore(index, event.depth);
+        return mate === null ? null : { mate };
+    }
+    use(language) {
+        if (language === this.language && this.checkpoints.length > 0) {
+            return;
+        }
+        this.language = language;
+        this.rules = bracketRules(language);
+        this.checkpoints = [{ line: 0, state: initialBracketState(), low: 0, stale: true }];
+        this.proven = 0;
+    }
+    nextStale(from) {
+        let index = from;
+        while (index < this.checkpoints.length && !this.checkpoints[index].stale) {
+            index++;
+        }
+        return index;
+    }
+    /* Lexes until the stretch that holds `line` is proven, or the budget is spent. */
+    prove(line) {
+        while (this.proven < this.checkpoints.length && this.checkpoints[this.proven].line <= line) {
+            if (this.budget <= 0) {
+                return false;
+            }
+            this.relex(this.proven, line);
+        }
+        return true;
+    }
+    /* Lexes the stale stretch at `index` again, cut into new ones, and stops early once it is past `until`. */
+    relex(index, until) {
+        const rope = this.text();
+        const next = this.checkpoints[index + 1];
+        const stop = next?.line ?? rope.lineCount;
+        const state = { ...this.checkpoints[index].state };
+        const added = [];
+        let current = this.checkpoints[index];
+        let line = current.line;
+        for (;;) {
+            const from = rope.lineBounds(line).start;
+            const end = Math.min(stop, from + this.stretchLength >= rope.length ? rope.lineCount : Math.max(line + 1, rope.lineAt(from + this.stretchLength)));
+            const to = end >= rope.lineCount ? rope.length : rope.lineBounds(end).start;
+            let low = state.stack?.depth ?? 0;
+            this.budget -= to - from;
+            lexBrackets(state, this.rules, rope.slice(from, to), 0, to - from, from, {
+                open() { },
+                close(_at, depth) {
+                    low = Math.min(low, depth - 1);
+                },
+                mismatch() {
+                    low = 0;
+                }
+            });
+            current.low = low;
+            current.stale = false;
+            if (end === stop) {
+                if (next !== undefined && !sameBracketState(state, next.state)) {
+                    next.state = state;
+                    next.stale = true;
+                }
+                break;
+            }
+            current = { line: end, state: { ...state }, low: 0, stale: true };
+            added.push(current);
+            line = end;
+            if (end > until || this.budget <= 0) {
+                break;
+            }
+        }
+        this.checkpoints.splice(index + 1, 0, ...added);
+        this.proven = this.nextStale(index + 1);
+    }
+    stretchOf(line) {
+        let low = 0;
+        let high = this.checkpoints.length - 1;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            if (this.checkpoints[middle].line <= line) {
+                low = middle;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        return low;
+    }
+    lexStretch(index, visitor) {
+        const rope = this.text();
+        const from = rope.lineBounds(this.checkpoints[index].line).start;
+        const next = this.checkpoints[index + 1];
+        const to = next === undefined ? rope.length : rope.lineBounds(next.line).start;
+        lexBrackets({ ...this.checkpoints[index].state }, this.rules, rope.slice(from, to), 0, to - from, from, visitor);
+    }
+    /* What the lexer made of the bracket at `offset`, with its mate when the stretch it is in holds that. */
+    eventAt(index, offset) {
+        let found;
+        // The openers this stretch opened; the ones from before it are only counted.
+        let opened = [];
+        this.lexStretch(index, {
+            open(at, depth) {
+                opened.push(at);
+                if (at === offset) {
+                    found = { kind: 'open', depth };
+                }
+            },
+            close(at, depth) {
+                const opener = opened.pop();
+                if (at === offset) {
+                    found = { kind: 'close', depth, ...(opener === undefined ? {} : { mate: opener }) };
+                }
+                else if (found?.kind === 'open' && found.mate === undefined && depth === found.depth) {
+                    found.mate = at;
+                }
+            },
+            mismatch(at) {
+                opened = [];
+                if (at === offset) {
+                    found = { kind: 'mismatch', depth: 0 };
+                }
+                else if (found?.kind === 'open' && found.mate === undefined) {
+                    found.mate = null;
+                }
+            }
+        });
+        return found;
+    }
+    /* The closer of an opener at `depth` that the stretch at `index` leaves open, undefined when nothing closes it and null when the budget ran out. */
+    closerAfter(index, depth) {
+        for (let current = index + 1; current < this.checkpoints.length; current++) {
+            if (!this.prove(this.checkpoints[current].line)) {
+                return null;
+            }
+            if (this.checkpoints[current].low >= depth) {
+                continue;
+            }
+            let result;
+            this.lexStretch(current, {
+                open() { },
+                close(at, closed) {
+                    if (result === undefined && closed === depth) {
+                        result = at;
+                    }
+                },
+                mismatch() {
+                    result ??= false;
+                }
+            });
+            return result === false ? undefined : result;
+        }
+        return undefined;
+    }
+    /* The opener at `depth` that is still open where the stretch at `index` starts. */
+    openerBefore(index, depth) {
+        for (let current = index - 1; current >= 0; current--) {
+            if (this.checkpoints[current].low >= depth) {
+                continue;
+            }
+            let result;
+            this.lexStretch(current, {
+                ...IGNORE,
+                open(at, opened) {
+                    if (opened === depth) {
+                        result = at;
+                    }
+                }
+            });
+            return result;
+        }
+        return undefined;
+    }
+}

package/dist/brackets.d.ts

@@ -2,4 +2,39 @@ export interface BracketIndex {
     pairs: ReadonlyMap<number, number>;
     unmatched: ReadonlySet<number>;
 }
+export interface BracketMatch {
+    mate: number | undefined;
+}
+export interface OpenBracket {
+    close: string;
+    template: boolean;
+    depth: number;
+    previous: OpenBracket | undefined;
+}
+export interface BracketState {
+    mode: 'code' | 'line-comment' | 'block-comment' | 'markup-comment' | 'string' | 'template' | 'regex';
+    quote: string;
+    inClass: boolean;
+    expression: boolean;
+    stack: OpenBracket | undefined;
+}
+export interface BracketRules {
+    script: boolean;
+    hash: boolean;
+    hashAtWordStart: boolean;
+    dash: boolean;
+    phpAttributes: boolean;
+    slash: boolean;
+    block: boolean;
+    markup: boolean;
+}
+export interface BracketVisitor {
+    open(at: number, depth: number): void;
+    close(at: number, depth: number): void;
+    mismatch(at: number): void;
+}
+export declare function initialBracketState(): BracketState;
+export declare function bracketRules(language: string): BracketRules;
+export declare function sameBracketState(left: BracketState, right: BracketState): boolean;
+export declare function lexBrackets(state: BracketState, rules: BracketRules, text: string, from: number, to: number, offset: number, visitor: BracketVisitor): void;
 export declare function scanBrackets(text: string, language?: string): BracketIndex;

package/dist/brackets.js

@@ -1,136 +1,204 @@
-import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.js';
-function skipLine(text, at) {
-    const end = text.indexOf('\n', at + 1);
-    return end < 0 ? text.length : end;
+import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpressionAfter, startsExpressionAt, startsWord } from './lexical.js';
+export function initialBracketState() {
+    return { mode: 'code', quote: '', inClass: false, expression: true, stack: undefined };
 }
-function skipComment(text, from, terminator) {
-    const end = text.indexOf(terminator, from);
-    return end < 0 ? text.length : end + terminator.length - 1;
+export function bracketRules(language) {
+    return {
+        script: isScript(language),
+        hash: hasHashComments(language),
+        hashAtWordStart: hashNeedsWordStart(language),
+        dash: hasDashComments(language),
+        phpAttributes: isPhp(language),
+        slash: hasSlashComments(language),
+        block: hasBlockComments(language),
+        markup: hasMarkupComments(language)
+    };
 }
-function skipString(text, at, quote, endsAtLineBreak) {
-    let cursor = at + 1;
-    for (; cursor < text.length; cursor++) {
-        if (text[cursor] === '\\') {
-            cursor++;
-        }
-        else if (text[cursor] === quote || (endsAtLineBreak && /[\r\n]/.test(text[cursor]))) {
-            break;
-        }
+export function sameBracketState(left, right) {
+    if (left.mode !== right.mode || left.quote !== right.quote || left.inClass !== right.inClass || left.expression !== right.expression) {
+        return false;
     }
-    return cursor;
+    let one = left.stack;
+    let other = right.stack;
+    while (one !== other) {
+        if (one === undefined || other === undefined || one.close !== other.close || one.template !== other.template || one.depth !== other.depth) {
+            return false;
+        }
+        one = one.previous;
+        other = other.previous;
+    }
+    return true;
 }
-function skipRegex(text, at) {
-    let inClass = false;
-    let cursor = at + 1;
-    for (; cursor < text.length; cursor++) {
-        const character = text[cursor];
-        if (character === '\\') {
-            cursor++;
-        }
-        else if (character === '[') {
-            inClass = true;
-        }
-        else if (character === ']') {
-            inClass = false;
-        }
-        else if ((character === '/' && !inClass) || /[\r\n]/.test(character)) {
-            break;
-        }
+function isSpace(character) {
+    const code = character.charCodeAt(0);
+    return code === 32 || (code >= 9 && code <= 13) || (code > 127 && /\s/.test(character));
+}
+function isCloser(character) {
+    return character === ')' || character === ']' || character === '}';
+}
+/* Where a comment that runs to `terminator` ends in `text`, or `to` when it goes on past it. */
+function commentEnd(state, text, at, to, terminator) {
+    const end = text.indexOf(terminator, at);
+    if (end < 0 || end + terminator.length > to) {
+        return to;
     }
-    return cursor;
+    state.mode = 'code';
+    return end + terminator.length - 1;
 }
-/* Lexical pairing for incomplete code; malformed nesting never produces crossing pairs. */
-export function scanBrackets(text, language = 'typescript') {
-    const pairs = new Map();
-    const unmatched = new Set();
-    const stack = [];
-    const script = isScript(language);
-    const hashComments = hasHashComments(language);
-    const hashAtWordStart = hashNeedsWordStart(language);
-    const dashComments = hasDashComments(language);
-    const phpAttributes = isPhp(language);
-    const slashComments = hasSlashComments(language);
-    const blockComments = hasBlockComments(language);
-    const markupComments = hasMarkupComments(language);
-    let inTemplate = false;
-    let expectsExpression = true;
-    for (let at = 0; at < text.length; at++) {
+/*
+ * Lexes `text` from `from` to `to`, continuing `state`, and reports every bracket of the code at its offset plus
+ * `offset`. A piece has to end at a line break or the end of the text, as nothing here looks past one.
+ */
+export function lexBrackets(state, rules, text, from, to, offset, visitor) {
+    for (let at = from; at < to; at++) {
         const char = text[at];
-        const next = text[at + 1];
-        if (inTemplate) {
-            if (char === '\\') {
-                at++;
-            }
-            else if (char === '`') {
-                inTemplate = false;
-                expectsExpression = false;
-            }
-            else if (char === '$' && next === '{') {
-                stack.push({ at: ++at, close: '}', template: true });
-                inTemplate = false;
-                expectsExpression = true;
+        if (state.mode !== 'code') {
+            switch (state.mode) {
+                case 'line-comment': {
+                    const end = text.indexOf('\n', at);
+                    if (end < 0 || end >= to) {
+                        return;
+                    }
+                    state.mode = 'code';
+                    at = end;
+                    continue;
+                }
+                case 'block-comment':
+                    at = commentEnd(state, text, at, to, '*/');
+                    continue;
+                case 'markup-comment':
+                    at = commentEnd(state, text, at, to, '-->');
+                    continue;
+                case 'string':
+                    if (char === '\\') {
+                        at++;
+                    }
+                    else if (char === state.quote || (rules.script && (char === '\n' || char === '\r'))) {
+                        state.mode = 'code';
+                    }
+                    continue;
+                case 'template':
+                    if (char === '\\') {
+                        at++;
+                    }
+                    else if (char === '`') {
+                        state.mode = 'code';
+                        state.expression = false;
+                    }
+                    else if (char === '$' && text[at + 1] === '{') {
+                        at++;
+                        const depth = (state.stack?.depth ?? 0) + 1;
+                        state.stack = { close: '}', template: true, depth, previous: state.stack };
+                        state.mode = 'code';
+                        state.expression = true;
+                        visitor.open(offset + at, depth);
+                    }
+                    continue;
+                case 'regex':
+                    if (char === '\\') {
+                        at++;
+                    }
+                    else if (char === '[') {
+                        state.inClass = true;
+                    }
+                    else if (char === ']') {
+                        state.inClass = false;
+                    }
+                    else if ((char === '/' && !state.inClass) || char === '\n' || char === '\r') {
+                        state.mode = 'code';
+                    }
+                    continue;
             }
             continue;
         }
-        if (/\s/.test(char)) {
+        if (isSpace(char)) {
             continue;
         }
-        if (markupComments && text.startsWith('<!--', at)) {
-            at = skipComment(text, at + 4, '-->');
+        const next = text[at + 1];
+        if (rules.markup && char === '<' && text.startsWith('<!--', at)) {
+            state.mode = 'markup-comment';
+            at += 3;
         }
-        else if ((slashComments && char === '/' && next === '/') ||
-            (dashComments && char === '-' && next === '-') ||
-            (hashComments && char === '#' && !(phpAttributes && next === '[') && (!hashAtWordStart || startsWord(text, at)))) {
-            at = skipLine(text, at);
+        else if ((rules.slash && char === '/' && next === '/') ||
+            (rules.dash && char === '-' && next === '-') ||
+            (rules.hash && char === '#' && !(rules.phpAttributes && next === '[') && (!rules.hashAtWordStart || startsWord(text, at)))) {
+            state.mode = 'line-comment';
         }
-        else if (blockComments && char === '/' && next === '*') {
-            at = skipComment(text, at + 2, '*/');
+        else if (rules.block && char === '/' && next === '*') {
+            state.mode = 'block-comment';
+            at++;
         }
         else if (char === '"' || char === "'") {
-            at = skipString(text, at, char, script);
-            expectsExpression = false;
+            state.mode = 'string';
+            state.quote = char;
+            state.expression = false;
         }
-        else if (script && char === '`') {
-            inTemplate = true;
+        else if (rules.script && char === '`') {
+            state.mode = 'template';
         }
-        else if (script && char === '/' && expectsExpression) {
-            at = skipRegex(text, at);
-            expectsExpression = false;
+        else if (rules.script && char === '/' && state.expression) {
+            state.mode = 'regex';
+            state.inClass = false;
+            state.expression = false;
         }
         else if (openers[char]) {
-            stack.push({ at, close: openers[char] });
-            expectsExpression = true;
+            const depth = (state.stack?.depth ?? 0) + 1;
+            state.stack = { close: openers[char], template: false, depth, previous: state.stack };
+            state.expression = true;
+            visitor.open(offset + at, depth);
         }
-        else if (/[)\]}]/.test(char)) {
-            const open = stack.at(-1);
+        else if (isCloser(char)) {
+            const open = state.stack;
             if (open?.close === char) {
-                stack.pop();
-                pairs.set(open.at, at);
-                pairs.set(at, open.at);
-                inTemplate = open.template === true;
+                state.stack = open.previous;
+                if (open.template) {
+                    state.mode = 'template';
+                }
+                visitor.close(offset + at, open.depth);
             }
             else {
-                unmatched.add(at);
-                // A mismatched closer keeps a distant opener from claiming it later.
-                for (const abandoned of stack.splice(0)) {
-                    unmatched.add(abandoned.at);
-                }
+                state.stack = undefined;
+                visitor.mismatch(offset + at);
             }
-            expectsExpression = false;
+            state.expression = false;
         }
         else if (isWordCharacter(char)) {
             const start = at;
-            while (at + 1 < text.length && isWordCharacter(text[at + 1])) {
+            while (at + 1 < to && isWordCharacter(text[at + 1])) {
                 at++;
             }
-            expectsExpression = startsExpression(text.slice(start, at + 1));
+            state.expression = startsExpressionAt(text, start, at + 1);
         }
         else {
-            expectsExpression = startsExpressionAfter(char);
+            state.expression = startsExpressionAfter(char);
         }
     }
-    for (const open of stack) {
-        unmatched.add(open.at);
+}
+/* Lexical pairing for incomplete code; malformed nesting never produces crossing pairs. */
+export function scanBrackets(text, language = 'typescript') {
+    const pairs = new Map();
+    const unmatched = new Set();
+    let open = [];
+    lexBrackets(initialBracketState(), bracketRules(language), text, 0, text.length, 0, {
+        open(at) {
+            open.push(at);
+        },
+        close(at) {
+            const opener = open.pop();
+            pairs.set(opener, at);
+            pairs.set(at, opener);
+        },
+        mismatch(at) {
+            unmatched.add(at);
+            // A mismatched closer keeps a distant opener from claiming it later.
+            for (const abandoned of open) {
+                unmatched.add(abandoned);
+            }
+            open = [];
+        }
+    });
+    for (const at of open) {
+        unmatched.add(at);
     }
     return { pairs, unmatched };
 }

package/dist/document.d.ts

@@ -1,3 +1,4 @@
+import type { BracketMatch } from './brackets.ts';
 import type { DocumentLine } from './rope.ts';
 import type { FindMatch, FindNextOptions, FindOptions } from './search.ts';
 import type { FoldingOptions, FoldingRange } from './structure.ts';
@@ -47,6 +48,7 @@ export declare class DocumentModel {
     occurrencesExhausted: boolean;
     private closers;
     private bracketCache?;
+    private bracketTracker;
     private scriptCache?;
     constructor(text?: string);
     getText(): string;
@@ -55,6 +57,7 @@ export declare class DocumentModel {
     getLineCount(): number;
     getLine(line: number): DocumentLine;
     slice(from: number, to: number): string;
+    matchBracket(offset: number, language?: string, limit?: number): BracketMatch | null | undefined;
     getSelections(): readonly Selection[];
     getSelectionCount(): number;
     getPrimary(): Selection;