@adecore/editor-core 0.22.1 → 0.23.1

package/src/offsets.ts

@@ -14,3 +14,27 @@ export function mapOffset(offset: number, edits: readonly TextEdit[], stayBefore
     }
     return offset + delta;
 }
+
+/* Reuse this index across selections while retaining both endpoint affinities. */
+export function offsetMapper(edits: readonly TextEdit[]): (offset: number, stayBefore?: boolean) => number {
+    const deltas = new Float64Array(edits.length + 1);
+    for (let index = 0; index < edits.length; index++) {
+        const edit = edits[index]!;
+        deltas[index + 1] = deltas[index]! + edit.text.length - (edit.to - edit.from);
+    }
+    return (offset, stayBefore = false) => {
+        let low = 0,
+            high = edits.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            const edit = edits[middle]!;
+            if (edit.to < offset || (edit.to === offset && !(stayBefore && edit.from === edit.to))) {
+                low = middle + 1;
+            } else {
+                high = middle;
+            }
+        }
+        const edit = edits[low];
+        return edit !== undefined && edit.from <= offset && offset < edit.to ? edit.from + deltas[low]! + edit.text.length : offset + deltas[low]!;
+    };
+}

package/src/php-markup.ts

@@ -0,0 +1,104 @@
+import type { TypingContext } from './typing-context.ts';
+
+const TAG = /<(\/?)([a-z][\w:-]*)(?=[\s/>]|$)/iy;
+const PHP = /<\?(?:php\b|=)/y;
+
+interface ScriptLexer {
+    initial(): TypingContext;
+    step(state: TypingContext, text: string, at: number, end: number, offset: number): number;
+}
+
+function finishTag(state: TypingContext, selfClosing: boolean, script: ScriptLexer, start: number): void {
+    state.markup = !selfClosing && state.element !== undefined ? 'raw' : undefined;
+    state.markupQuote = undefined;
+    state.embed = state.markup === 'raw' && state.element === 'script' ? script.initial() : undefined;
+    if (state.embed !== undefined) {
+        state.embed.embedStart = start;
+    }
+    if (selfClosing) {
+        state.element = undefined;
+    }
+}
+
+export function scanPhpMarkup(state: TypingContext, text: string, from: number, end: number, offset: number, script: ScriptLexer): number {
+    for (let at = from; at < end; at++) {
+        const char = text[at]!;
+        if (char === '<' && text[at + 1] === '?') {
+            PHP.lastIndex = at;
+            const open = PHP.exec(text);
+            if (open !== null) {
+                if (state.markup === 'equals') {
+                    state.markup = 'value';
+                }
+                state.mode = 'code';
+                state.expression = true;
+                state.word = '';
+                return at + open[0].length - 1;
+            }
+        }
+        if (state.markup === 'comment') {
+            if (text.startsWith('-->', at) && at + 3 <= end) {
+                state.markup = undefined;
+                at += 2;
+            }
+            continue;
+        }
+        if (state.markup === 'value' && state.markupQuote !== undefined) {
+            if (char === state.markupQuote) {
+                state.markup = 'tag';
+                state.markupQuote = undefined;
+            }
+            continue;
+        }
+        if (char === '<') {
+            if (state.markup !== 'raw' && text.startsWith('<!--', at)) {
+                // HTML also closes these two comments immediately, without a later -->.
+                const empty = text.startsWith('<!-->', at) ? 5 : text.startsWith('<!--->', at) ? 6 : 0;
+                state.markup = empty > 0 && at + empty <= end ? undefined : 'comment';
+                state.element = undefined;
+                at += (empty || 4) - 1;
+                continue;
+            }
+            TAG.lastIndex = at;
+            const tag = TAG.exec(text);
+            const name = tag?.[2]?.toLowerCase();
+            if (state.markup === 'raw' && (tag?.[1] !== '/' || name !== state.element)) {
+                if (state.embed !== undefined) {
+                    at = script.step(state.embed, text, at, end, offset);
+                }
+                continue;
+            }
+            state.embed = undefined;
+            state.element = tag?.[1] !== '/' && (name === 'script' || name === 'style' || name === 'textarea' || name === 'title') ? name : undefined;
+            state.markup = tag === null ? undefined : 'tag';
+            state.markupQuote = undefined;
+            if (tag !== null) {
+                at += tag[0].length - 1;
+            }
+            continue;
+        }
+        if (state.embed !== undefined) {
+            at = script.step(state.embed, text, at, end, offset);
+            continue;
+        }
+        if (state.markup === undefined || state.markup === 'raw') {
+            continue;
+        }
+        if (char === '>') {
+            finishTag(state, false, script, offset + at + 1);
+        } else if (char === '/' && text[at + 1] === '>' && at + 2 <= end) {
+            finishTag(state, true, script, offset + at + 2);
+            at++;
+        } else if (/\s/u.test(char)) {
+            if (state.markup === 'value') {
+                state.markup = 'tag';
+            }
+        } else if (state.markup === 'equals') {
+            state.markup = 'value';
+            state.markupQuote = char === '"' || char === "'" ? char : undefined;
+        } else if (state.markup === 'tag' && char === '=') {
+            state.markup = 'equals';
+        }
+    }
+    return end - 1;
+}

package/src/rope.ts

@@ -7,14 +7,14 @@ export interface DocumentLine {
 }
 
 /*
- * A persistent AVL tree of text chunks of at most `chunkSize` UTF-16 code units. Every node knows
+ * 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.
  */
 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 Node = Leaf | Branch;
-const chunkSize = 2048;
+export const ROPE_CHUNK_SIZE = 2048;
 
 function leaf(text: string): Leaf | null {
     if (!text.length) {
@@ -56,7 +56,7 @@ function join(left: Node | null, right: Node | null): Node | null {
     if (!right) {
         return left;
     }
-    if ('text' in left && 'text' in right && left.length + right.length <= chunkSize) {
+    if ('text' in left && 'text' in right && left.length + right.length <= ROPE_CHUNK_SIZE) {
         return leaf(left.text + right.text);
     }
     if (left.height > right.height + 1 && 'left' in left) {
@@ -88,8 +88,8 @@ function split(node: Node | null, offset: number): [Node | null, Node | null] {
 
 function build(text: string): Node | null {
     const leaves: Node[] = [];
-    for (let offset = 0; offset < text.length; offset += chunkSize) {
-        leaves.push(leaf(text.slice(offset, offset + chunkSize))!);
+    for (let offset = 0; offset < text.length; offset += ROPE_CHUNK_SIZE) {
+        leaves.push(leaf(text.slice(offset, offset + ROPE_CHUNK_SIZE))!);
     }
     const tree = (from: number, to: number): Node | null => {
         if (from === to) {
@@ -187,6 +187,36 @@ export class TextRope {
         return new TextRope(join(join(before, build(text)), after));
     }
 
+    /* Dense validated batches rebuild once, rather than repeatedly splitting and rescanning leaves. */
+    rebuild(edits: readonly { from: number; to: number; text: string }[]): TextRope {
+        const chunks = chunksOf(this.root, 0, this.length);
+        let chunk = chunks.next();
+        let column = 0;
+        let offset = 0;
+        const pieces: string[] = [];
+        const advance = (end: number, keep: boolean): void => {
+            while (offset < end && !chunk.done) {
+                const count = Math.min(end - offset, chunk.value.length - column);
+                if (keep) {
+                    pieces.push(chunk.value.slice(column, column + count));
+                }
+                offset += count;
+                column += count;
+                if (column === chunk.value.length) {
+                    chunk = chunks.next();
+                    column = 0;
+                }
+            }
+        };
+        for (const edit of edits) {
+            advance(edit.from, true);
+            pieces.push(edit.text);
+            advance(edit.to, false);
+        }
+        advance(this.length, true);
+        return TextRope.from(pieces.join(''));
+    }
+
     /* Whether both ropes hold the same text in `[from, to)`, which has to be the same range of both. */
     equalsRange(other: TextRope, from: number, to: number): boolean {
         if (this.root === other.root) {

package/src/script-source.ts

@@ -0,0 +1,43 @@
+import type { TypingContext } from './typing-context.ts';
+
+export function scriptSource(text: string, start: number, complete: boolean, context: (offset: number) => TypingContext | null): string | undefined {
+    const events = /<\?(?:php\b|=)|\?>|<\/script(?=[\s/>]|$)/gi;
+    const chunks: string[] = [];
+    let cursor = 0;
+    let island: number | undefined;
+    const finish = (end: number): string => {
+        chunks.push(text.slice(cursor, island ?? end));
+        if (island !== undefined) {
+            chunks.push(' '.repeat(end - island));
+        }
+        return chunks.join('');
+    };
+    for (const match of text.matchAll(events)) {
+        const state = context(start + match.index);
+        if (state === null) {
+            return undefined;
+        }
+        const inScript = state.embedded === 'javascript' && state.embedStart === start;
+        if (/^<\?(?:php\b|=)/.test(match[0])) {
+            if (inScript) {
+                island = match.index;
+            }
+        } else if (match[0] === '?>') {
+            if (island !== undefined && state.embed?.embedStart === start && (state.mode === 'code' || state.mode === 'line-comment')) {
+                let end = match.index + 2;
+                if (text.startsWith('\r\n', end)) {
+                    end += 2;
+                } else if (text[end] === '\n') {
+                    end++;
+                }
+                // Spaces preserve document offsets without treating PHP source newlines as script text.
+                chunks.push(text.slice(cursor, island), ' '.repeat(end - island));
+                cursor = end;
+                island = undefined;
+            }
+        } else if (match[0].startsWith('</') && inScript) {
+            return finish(match.index);
+        }
+    }
+    return complete ? finish(text.length) : undefined;
+}

package/src/search.ts

@@ -1,3 +1,4 @@
+import { clampInteger } from './rope.ts';
 import { replaceWithCaseRespect } from './preserve-case.ts';
 
 export interface FindOptions {
@@ -40,8 +41,14 @@ function characterBefore(text: string, offset: number): string {
 
 /* Invalid bounds throw `RangeError`, an invalid expression `SyntaxError`. A zero-width match advances by one code point. */
 export function findMatches(text: string, query: string, revision: number, options: FindOptions = {}): FindMatch[] {
+    return Array.from(iterateMatches(text, query, revision, options));
+}
+
+/* Validation and regex execution start when the iterator advances. */
+export function* iterateMatches(text: string, query: string, revision: number, options: FindOptions = {}): Generator<FindMatch, void, unknown> {
+    options = { ...options };
     if (!query && !options.regex) {
-        return [];
+        return;
     }
     const from = options.from ?? 0;
     const to = options.to ?? text.length;
@@ -55,8 +62,8 @@ export function findMatches(text: string, query: string, revision: number, optio
     const source = options.regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     const expression = new RegExp(source, `gmu${options.caseSensitive ? '' : 'i'}`);
     expression.lastIndex = from;
-    const matches: FindMatch[] = [];
-    while (matches.length < maximum) {
+    let count = 0;
+    while (count < maximum) {
         const match = expression.exec(text);
         if (!match || match.index > to) {
             break;
@@ -66,7 +73,8 @@ export function findMatches(text: string, query: string, revision: number, optio
             !options.wholeWord ||
             (!wordCharacter.test(characterBefore(text, match.index)) && !wordCharacter.test(String.fromCodePoint(text.codePointAt(end) ?? 0)));
         if (match.index >= from && end <= to && !splitsSurrogate(text, match.index) && !splitsSurrogate(text, end) && wholeWord) {
-            matches.push({
+            count++;
+            yield {
                 from: match.index,
                 to: end,
                 text: match[0],
@@ -74,23 +82,65 @@ export function findMatches(text: string, query: string, revision: number, optio
                 groups: match.groups ? { ...match.groups } : undefined,
                 regex: options.regex === true,
                 revision
-            });
+            };
         }
         if (!match[0].length) {
             expression.lastIndex = match.index + ((text.codePointAt(match.index) ?? 0) > 0xffff ? 2 : 1);
         }
     }
-    return matches;
+}
+
+/* Keeps the original match grid; starting RegExp at the caret would create overlapping matches. */
+export function findMatchFrom(text: string, query: string, revision: number, offset: number, options: FindNextOptions = {}): FindMatch | null {
+    const position = clampInteger(offset, text.length);
+    let first: FindMatch | null = null;
+    let last: FindMatch | null = null;
+    let previous: FindMatch | null = null;
+    for (const match of iterateMatches(text, query, revision, options)) {
+        first ??= match;
+        last = match;
+        if (!options.backwards && match.from >= position) {
+            return match;
+        }
+        if (options.backwards) {
+            if (match.to <= position) {
+                previous = match;
+            } else if (previous !== null || options.wrap === false) {
+                return previous;
+            }
+        }
+    }
+    return options.backwards ? (previous ?? (options.wrap === false ? null : last)) : options.wrap === false ? null : first;
 }
 
 /* Expands the JavaScript `$` patterns of a regex replacement, and gives it the case of the match when asked. Literal replacements are returned as they are. */
-export function replacementText(text: string, match: FindMatch, replacement: string, literal = false, preserveCase = false): string {
-    const expanded = literal || !match.regex ? replacement : expandPatterns(text, match, replacement);
-    return preserveCase ? replaceWithCaseRespect(expanded, match.text) : expanded;
+export function replacementText(text: string, match: FindMatch, replacement: string, literal = false, preserveCase = false, maxCharacters = Infinity): string {
+    if (maxCharacters !== Infinity && (!Number.isSafeInteger(maxCharacters) || maxCharacters < 0)) {
+        throw new RangeError('The replacement character limit must be nonnegative.');
+    }
+    const expanded = literal || !match.regex ? replacement : expandPatterns(text, match, replacement, maxCharacters);
+    if (expanded.length > maxCharacters) {
+        throw new RangeError('Replacement output exceeds its character limit.');
+    }
+    const result = preserveCase ? replaceWithCaseRespect(expanded, match.text) : expanded;
+    if (result.length > maxCharacters) {
+        throw new RangeError('Replacement output exceeds its character limit.');
+    }
+    return result;
 }
 
-function expandPatterns(text: string, match: FindMatch, replacement: string): string {
-    return replacement.replace(/\$(\$|&|`|'|\d{1,2}|<[^>]*>)/g, (token: string, group: string) => {
+function expandPatterns(text: string, match: FindMatch, replacement: string, maxCharacters: number): string {
+    const pieces: string[] = [];
+    let characters = 0,
+        cursor = 0;
+    const append = (value: string): void => {
+        characters += value.length;
+        if (characters > maxCharacters) {
+            throw new RangeError('Replacement output exceeds its character limit.');
+        }
+        pieces.push(value);
+    };
+    const expand = (token: string, group: string): string => {
         if (group === '$') {
             return '$';
         }
@@ -115,5 +165,12 @@ function expandPatterns(text: string, match: FindMatch, replacement: string): st
             return (match.captures[first - 1] ?? '') + group[1];
         }
         return token;
-    });
+    };
+    for (const found of replacement.matchAll(/\$(\$|&|`|'|\d{1,2}|<[^>]*>)/g)) {
+        append(replacement.slice(cursor, found.index));
+        append(expand(found[0], found[1]!));
+        cursor = found.index + found[0].length;
+    }
+    append(replacement.slice(cursor));
+    return pieces.join('');
 }

package/src/types.ts

@@ -49,6 +49,8 @@ export interface EditorSnapshot {
     /* The same change in order, as a sequence a language server can follow; present when the text changed. */
     contentEdits?: readonly ContentEdit[];
     source?: ChangeSource;
+    /* The edit is what a person's typing did, a line break from Enter included, though it ran as a command. */
+    typed?: boolean;
 }
 
 export interface EditOptions {
@@ -57,6 +59,10 @@ export interface EditOptions {
     source?: ChangeSource;
     /* Edits with the same group join one undo step until a selection change or an undo closes it. */
     historyGroup?: string;
+    /* Joins the undo step before it when the document is exactly as that step left it, so one undo takes both back. */
+    joinPrevious?: boolean;
+    /* Reported on the snapshot: the edit is what a person's typing did, though it ran as a command. */
+    typed?: boolean;
 }
 
 export type EditorCommand =

package/src/typing-context.ts

@@ -13,6 +13,7 @@ import {
     startsExpressionAfter,
     startsWord
 } from './lexical.ts';
+import { scanPhpMarkup } from './php-markup.ts';
 import type { DocumentLine } from './rope.ts';
 
 export interface TypingBracket {
@@ -43,6 +44,15 @@ export interface TypingContext {
     word: string;
     /* Where the comment the lexer is in began, in the document. */
     commentStart?: number;
+    /* PHP preserves these fields while code inside an attribute or raw block runs. */
+    markup?: 'tag' | 'equals' | 'value' | 'comment' | 'raw';
+    markupQuote?: '"' | "'";
+    element?: 'script' | 'style' | 'textarea' | 'title';
+    embed?: TypingContext;
+    embedded?: 'javascript';
+    embedStart?: number;
+    /* Only a scan result keeps this; PHP consumes the newline immediately after a closing tag. */
+    phpClose?: number;
 }
 
 interface Rules {
@@ -58,6 +68,12 @@ interface Rules {
 
 const PHP_HEREDOC = /^<<<[ \t]*(["']?)([A-Za-z_]\w*)\1[ \t]*$/;
 const PHP_OPEN = /<\?(?:php\b|=)/;
+const PHP_INITIAL_LINES = 64;
+const PHP_INITIAL_CHARACTERS = 64 * 1024;
+// Quoted PHP tags within a bare code fragment must not turn its prelude into output.
+const PHP_FRAGMENT_START =
+    /^(?:[$'"#]|\/[/*]|(?:abstract|class|const|declare|echo|enum|final|for|foreach|function|if|include(?:_once)?|interface|namespace|print|readonly|require(?:_once)?|return|switch|throw|trait|try|use|while)\b|[A-Za-z_]\w*\s*(?:\(|::))/;
+
 const controlWords = /^(for|for-await|if|while|switch|catch|with)$/;
 const blockWords = /^(else|try|finally|do)$/;
 
@@ -151,6 +167,7 @@ function scanCode(state: TypingContext, rules: Rules, text: string, at: number,
         }
     }
     if (rules.php && char === '?' && next === '>') {
+        state.phpClose = offset + at + 2;
         state.mode = 'html';
         return at + 1;
     }
@@ -214,9 +231,34 @@ function closeBracket(state: TypingContext, char: string): void {
     state.word = bracket.control ? 'control-close' : '';
 }
 
+let scriptRules: Rules | undefined;
+
+function stepScript(state: TypingContext, text: string, at: number, end: number, offset: number): number {
+    if (state.mode === 'line-comment') {
+        return at;
+    }
+    if (state.mode === 'block-comment') {
+        return scanComment(state, text, at, end);
+    }
+    return state.mode === 'code' ? scanCode(state, (scriptRules ??= rulesOf('javascript')), text, at, end, offset) : scanLiteral(state, text, at, end, offset);
+}
+
+const scriptLexer = { initial, step: stepScript };
+
+function normalizeLine(state: TypingContext, multilineQuotes: boolean): void {
+    if (state.mode === 'line-comment' || state.mode === 'regex' || (state.mode === 'quote' && !multilineQuotes && !state.escaped)) {
+        state.mode = 'code';
+        state.quote = undefined;
+        state.commentStart = undefined;
+        state.expression = true;
+    }
+    state.escaped = false;
+}
+
 /* Lexes `text` up to `end`, from the state the line started in. `offset` is where the line starts in the document. */
 function scan(text: string, end: number, start: TypingContext, rules: Rules, offset: number): TypingContext {
-    const state = { ...start };
+    // An embedded lexer must not mutate the script state cached at the line start.
+    const state = { ...start, embed: start.embed === undefined ? undefined : { ...start.embed } };
     for (let at = 0; at < end; at++) {
         if (state.mode === 'line-comment') {
             // A PHP line comment ends at its line break and at a closing tag.
@@ -224,18 +266,12 @@ function scan(text: string, end: number, start: TypingContext, rules: Rules, off
             if (tag < 0 || tag >= end) {
                 break;
             }
+            state.phpClose = offset + tag + 2;
             state.mode = 'html';
             state.commentStart = undefined;
             at = tag + 1;
         } else if (state.mode === 'html') {
-            const open = PHP_OPEN.exec(text.slice(at));
-            if (open === null || at + open.index >= end) {
-                break;
-            }
-            state.mode = 'code';
-            state.expression = true;
-            state.word = '';
-            at += open.index + open[0].length - 1;
+            at = scanPhpMarkup(state, text, at, end, offset, scriptLexer);
         } else if (state.mode === 'heredoc') {
             const closing = new RegExp(`^[\\t ]*${state.quote}(?![\\w])`).exec(text);
             if (closing === null) {
@@ -265,7 +301,13 @@ function sameState(left: TypingContext, right: TypingContext): boolean {
         left.bracket === right.bracket &&
         left.expression === right.expression &&
         left.word === right.word &&
-        left.commentStart === right.commentStart
+        left.commentStart === right.commentStart &&
+        left.markup === right.markup &&
+        left.markupQuote === right.markupQuote &&
+        left.element === right.element &&
+        left.phpClose === right.phpClose &&
+        left.embedStart === right.embedStart &&
+        (left.embed === right.embed || (left.embed !== undefined && right.embed !== undefined && sameState(left.embed, right.embed)))
     );
 }
 
@@ -274,6 +316,7 @@ export class TypingContexts {
     private readonly line: (index: number) => DocumentLine;
     private states: TypingContext[] = [initial()];
     private language = '';
+    private decidingLine = 0;
 
     constructor(line: (index: number) => DocumentLine) {
         this.line = line;
@@ -281,16 +324,34 @@ export class TypingContexts {
 
     invalidate(line = 0): void {
         this.states.length = Math.min(this.states.length, Math.max(1, line + 1));
-        if (line === 0) {
+        if (line <= this.decidingLine) {
             this.language = '';
         }
     }
 
-    /* A PHP file that opens with markup, and not with a tag, starts outside the PHP. */
     private initialState(language: string): TypingContext {
         const state = initial();
-        if (language === 'php' && /^\s*<(?![?<])/.test(this.line(0).text)) {
-            state.mode = 'html';
+        this.decidingLine = 0;
+        if (language !== 'php') {
+            return state;
+        }
+        let remaining = PHP_INITIAL_CHARACTERS;
+        for (let line = 0; line < PHP_INITIAL_LINES && remaining > 0; line++) {
+            this.decidingLine = line;
+            const source = this.line(line);
+            const sample = source.text.slice(0, remaining);
+            remaining -= sample.length;
+            const text = sample.trimStart();
+            if (text !== '') {
+                const open = PHP_OPEN.exec(text);
+                if (/^<(?![?<])/.test(text) || (open !== null && open.index > 0 && !PHP_FRAGMENT_START.test(text))) {
+                    state.mode = 'html';
+                }
+                return state;
+            }
+            if (source.end === source.next) {
+                break;
+            }
         }
         return state;
     }
@@ -306,17 +367,19 @@ export class TypingContexts {
             const previous = this.states.at(-1)!;
             const source = this.line(this.states.length - 1);
             const next = scan(source.text, source.text.length, previous, rules, source.start);
-            // Only PHP and Rust strings run past a line break without a trailing backslash.
-            if (next.mode === 'line-comment' || next.mode === 'regex' || (next.mode === 'quote' && !/^(php|rust|rs)$/i.test(id) && !next.escaped)) {
-                next.mode = 'code';
-                next.quote = undefined;
-                next.commentStart = undefined;
-                next.expression = true;
+            // A PHP island's source newlines are not newlines in the emitted script.
+            if (next.mode === 'html' && next.embed !== undefined && next.phpClose !== source.end) {
+                normalizeLine(next.embed, false);
+            }
+            next.phpClose = undefined;
+            normalizeLine(next, /^(php|rust|rs)$/i.test(id));
+            if (next.mode === 'html' && next.markup === 'value' && next.markupQuote === undefined) {
+                next.markup = 'tag';
             }
-            next.escaped = false;
             this.states.push(sameState(next, previous) ? previous : next);
         }
         const source = this.line(line);
-        return scan(source.text, column, this.states[line], rules, source.start);
+        const state = scan(source.text, column, this.states[line], rules, source.start);
+        return state.mode === 'html' && state.embed !== undefined ? { ...state.embed, markup: 'raw', element: 'script', embedded: 'javascript' } : state;
     }
 }