@adecore/editor-core 0.22.1 → 0.23.0

package/dist/comments.js

@@ -1,9 +1,11 @@
+import { editRegions, phpLiteralAt, phpTagAt } from './edit-regions.js';
+import { hasJsx } from './markup-regions.js';
 import { commentSyntax } from './languages.js';
 import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.js';
 import { mapOffset } from './offsets.js';
 import { indentationColumn } from './structure.js';
-function syntaxOf(source, options, line) {
-    const syntax = commentSyntax(options.language, source.region(line));
+function syntaxOf(regions, options, line, offset) {
+    const syntax = commentSyntax(options.language, regions(line, offset));
     return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
 }
 /* The runs of adjacent lines the selections touch. A selection that ends at the start of a line does not touch it. */
@@ -62,19 +64,42 @@ function geometryOf(source, edits, index) {
  * The markers go in at the smallest indentation of the lines, and a lone caret moves to the next line.
  */
 export function planLineComments(source, selections, options) {
+    const regions = editRegions(source, options.language);
     const blocks = blocksOf(source, selections, options.lineSpan);
-    const syntaxes = blocks.map((block) => syntaxOf(source, options, block.first));
-    if (syntaxes.some((syntax) => syntax.line === null && syntax.block === null)) {
-        return null;
+    const lineBased = new Map();
+    for (const block of blocks) {
+        let marker;
+        let mixed = false;
+        const firstSyntax = hasJsx(options.language) && block.first !== block.last ? syntaxOf(regions, options, block.first) : undefined;
+        for (let line = block.first; line <= block.last; line++) {
+            const syntax = firstSyntax ?? syntaxOf(regions, options, line);
+            const effective = syntax.line === null ? syntax : { ...syntax, block: null };
+            lineBased.set(line, effective);
+            if (effective.line !== null || effective.block !== null) {
+                mixed ||=
+                    marker !== undefined &&
+                        (marker.line !== effective.line || marker.block?.open !== effective.block?.open || marker.block?.close !== effective.block?.close);
+                marker ??= effective;
+            }
+        }
+        // Commenting a region opener would change the markers needed for the next toggle.
+        if (mixed && /^(php|vue)$/i.test(options.language)) {
+            for (let line = block.first; line <= block.last; line++) {
+                lineBased.set(line, { line: null, block: null });
+            }
+        }
     }
-    const lineBased = syntaxes.map((syntax) => (syntax.line === null ? syntax : { ...syntax, block: null }));
     let allCommented = true;
     let anyCommented = false;
-    for (const [position, block] of blocks.entries()) {
+    for (const block of blocks) {
         const single = block.first === block.last;
         for (let line = block.first; line <= block.last; line++) {
             const text = source.line(line).text;
-            const commented = isCommented(text, lineBased[position], !single);
+            const syntax = lineBased.get(line);
+            if (syntax.line === null && syntax.block === null) {
+                continue;
+            }
+            const commented = isCommented(text, syntax, !single);
             if (commented && !isBlank(text)) {
                 anyCommented = true;
             }
@@ -88,8 +113,8 @@ export function planLineComments(source, selections, options) {
     }
     const edits = [];
     const placed = new Set();
-    for (const [position, block] of blocks.entries()) {
-        const syntax = lineBased[position];
+    for (const block of blocks) {
+        const syntax = lineBased.get(block.first);
         const multiline = block.first !== block.last;
         const startingNewLine = !multiline &&
             block.carets.length === 1 &&
@@ -98,6 +123,10 @@ export function planLineComments(source, selections, options) {
         const minimum = allCommented ? 0 : minimumIndent(source, block, syntax, options);
         for (let line = block.first; line <= block.last; line++) {
             const bounds = source.line(line);
+            const syntax = lineBased.get(line);
+            if (syntax.line === null && syntax.block === null) {
+                continue;
+            }
             const edit = allCommented
                 ? uncommentLine(bounds.start, bounds.text, syntax)
                 : commentLine(bounds.start, bounds.text, syntax, minimum, multiline, startingNewLine, options);
@@ -201,13 +230,17 @@ function finalSelections(source, selections, blocks, edits, allCommented, placed
     if (!moveCarets) {
         return result;
     }
-    for (const [position, block] of blocks.entries()) {
+    for (const block of blocks) {
         for (const index of block.carets) {
             const selection = selections[index];
             const { from, to } = rangeOf(selection);
             const line = source.lineAt(from);
             if (from === to) {
-                result[index] = caretAfter(source, sorted, line, span?.(line).last ?? line, selection.head, allCommented, placed, syntaxes[position]);
+                const syntax = syntaxes.get(line);
+                if (syntax.line === null && syntax.block === null) {
+                    continue;
+                }
+                result[index] = caretAfter(source, sorted, line, span?.(line).last ?? line, selection.head, allCommented, placed, syntax);
                 continue;
             }
             const lastLine = source.lineAt(to - 1);
@@ -241,7 +274,7 @@ function commentAround(source, offset, block) {
     if ((context.mode !== 'block-comment' && context.mode !== 'html-comment') || context.commentStart === undefined) {
         return null;
     }
-    const from = context.commentStart;
+    const from = block.open === '{/*' && source.charAt(context.commentStart - 1) === '{' ? context.commentStart - 1 : context.commentStart;
     if (source.slice(from, from + block.open.length) !== block.open) {
         return null;
     }
@@ -264,12 +297,32 @@ function commentOf(source, from, to, block) {
  * With nothing selected it opens an empty comment around the caret.
  */
 export function planBlockComment(source, selections, options) {
+    const regions = editRegions(source, options.language);
     const edits = [];
     const result = [];
     let offsetDelta = 0;
     for (const selection of selections) {
         const { from, to } = rangeOf(selection);
-        const block = syntaxOf(source, options, source.lineAt(from)).block;
+        if (/^php$/i.test(options.language)) {
+            const context = source.context(from);
+            const { mode } = context;
+            const endContext = source.context(to);
+            const endMode = endContext.mode;
+            const endsLineComment = mode === 'code' && endMode === 'line-comment' && source.slice(to, source.line(source.lineAt(to)).end).trim() === '';
+            const text = source.slice(from, to);
+            // Wrapping a PHP tag can move a closing marker into a different language.
+            if (phpLiteralAt(source, from) ||
+                phpLiteralAt(source, to) ||
+                phpTagAt(source, from) ||
+                phpTagAt(source, to) ||
+                (mode !== endMode && !endsLineComment) ||
+                context.embedStart !== endContext.embedStart ||
+                /<\?(?:php\b|=)/.test(text) ||
+                (mode !== 'html' && context.embedded === undefined && text.includes('?>'))) {
+                return null;
+            }
+        }
+        const block = syntaxOf(regions, options, source.lineAt(from), from).block;
         if (!block) {
             return null;
         }

package/dist/doc-comments.d.ts

@@ -0,0 +1,10 @@
+export interface DocComment {
+    from: number;
+    to: number;
+    startLine: number;
+    endLine: number;
+    indent: string;
+    body: string;
+}
+export declare const MAX_DOC_COMMENTS = 500;
+export declare function findDocComments(text: string, language: string, limit?: number): DocComment[];

package/dist/doc-comments.js

@@ -0,0 +1,85 @@
+import { commentRole } from './fold-roles.js';
+import { commentSyntax, vueRegionAt } from './languages.js';
+import { scanStructure } from './structure.js';
+/* Past this many comments in one document the rest are left as text. */
+export const MAX_DOC_COMMENTS = 500;
+function bodyOf(inner) {
+    const lines = inner.split(/\r\n|\r|\n/).map((line, index) => (index === 0 ? line.replace(/^[ \t]+/, '') : line.replace(/^[ \t]*\*?[ \t]?/, '')));
+    const last = lines.length - 1;
+    lines[last] = lines[last].replace(/[ \t*]+$/, '');
+    while (lines.length > 0 && lines[0].trim() === '') {
+        lines.shift();
+    }
+    while (lines.length > 0 && lines.at(-1).trim() === '') {
+        lines.pop();
+    }
+    return lines.map((line) => line.replace(/[ \t]+$/, '')).join('\n');
+}
+const HEREDOC_OPENER = /<<<[ \t]*(?:'(\w+)'|"(\w+)"|(\w+))\r?\n/g;
+/* The bodies of PHP heredocs and nowdocs, which the structure scan reads as code. Offsets of the first character after the opener and of the closing label. */
+function heredocBodies(text) {
+    const result = [];
+    for (const opener of text.matchAll(HEREDOC_OPENER)) {
+        const label = opener[1] ?? opener[2] ?? opener[3];
+        const from = opener.index + opener[0].length;
+        const closer = new RegExp(`^[ \\t]*${label}\\b`, 'm').exec(text.slice(from));
+        result.push([from, closer === null ? text.length : from + closer.index]);
+    }
+    return result;
+}
+/*
+ * The block comments that open with two stars and have their lines to themselves: nothing but
+ * whitespace before the opener and after the closer. Only languages that write block comments as
+ * a slash and a star have any, and a Vue file has them in its script. A comment that shares a line
+ * with code is left out, since a row could not take its lines without hiding the code. A banner of
+ * three stars or more is no documentation, and nor is the text of a PHP heredoc or nowdoc. A heredoc
+ * body is still read as code by the scan, so a quote in it can hide the comments that follow.
+ */
+export function findDocComments(text, language, limit = MAX_DOC_COMMENTS) {
+    const vue = language.toLowerCase() === 'vue';
+    const syntax = commentSyntax(language, vue ? 'script' : null);
+    if (syntax.block?.open !== '/*' || syntax.line !== '//' || !text.includes('/**')) {
+        return [];
+    }
+    const result = [];
+    const bodies = language.toLowerCase() === 'php' && text.includes('<<<') ? heredocBodies(text) : [];
+    const lines = vue ? text.split(/\r\n|\r|\n/) : null;
+    let counted = 0;
+    let line = 0;
+    for (const range of scanStructure(text)) {
+        if (result.length >= limit) {
+            break;
+        }
+        if (range.kind !== 'comment' || commentRole((from, to) => text.slice(from, to), range.from, range.to) === undefined) {
+            continue;
+        }
+        // Three stars or more is a banner, not a comment about the code under it.
+        if (text[range.from + 3] === '*' || bodies.some(([from, to]) => range.from >= from && range.from < to)) {
+            continue;
+        }
+        const lineStart = Math.max(text.lastIndexOf('\n', range.from - 1), text.lastIndexOf('\r', range.from - 1)) + 1;
+        const newline = text.slice(range.to).search(/[\r\n]/);
+        const lineEnd = newline === -1 ? text.length : range.to + newline;
+        const before = text.slice(lineStart, range.from);
+        if (!/^[ \t]*$/.test(before) || !/^[ \t]*$/.test(text.slice(range.to, lineEnd))) {
+            continue;
+        }
+        for (; counted < range.from; counted++) {
+            if (text[counted] === '\n' || (text[counted] === '\r' && text[counted + 1] !== '\n')) {
+                line++;
+            }
+        }
+        const startLine = line;
+        if (lines !== null && vueRegionAt((index) => lines[index] ?? '', startLine) !== 'script') {
+            continue;
+        }
+        let endLine = startLine;
+        for (let at = range.from; at < range.to; at++) {
+            if (text[at] === '\n' || (text[at] === '\r' && text[at + 1] !== '\n')) {
+                endLine++;
+            }
+        }
+        result.push({ from: range.from, to: range.to, startLine, endLine, indent: before, body: bodyOf(text.slice(range.innerFrom + 1, range.innerTo)) });
+    }
+    return result;
+}

package/dist/document.d.ts

@@ -8,6 +8,10 @@ export interface OffsetRange {
     readonly to: number;
 }
 export interface DocumentEditOptions extends EditOptions {
+    selectionPositions?: readonly {
+        readonly anchor: Position;
+        readonly head: Position;
+    }[];
     expectedRevision?: number;
 }
 export interface TypeTextOptions extends CommandOptions {
@@ -43,6 +47,7 @@ export declare class DocumentModel {
     occurrencesExhausted: boolean;
     private closers;
     private bracketCache?;
+    private scriptCache?;
     constructor(text?: string);
     getText(): string;
     getLength(): number;
@@ -66,6 +71,7 @@ export declare class DocumentModel {
     findNext(query: string, from?: number, options?: FindNextOptions): FindMatch | null;
     replace(match: FindMatch, replacement: string, options?: ReplaceOptions): boolean;
     replaceAll(query: string, replacement: string, options?: ReplaceAllOptions): number;
+    replaceMatches(matches: readonly FindMatch[], replacement: string, options?: ReplaceOptions): number;
     getFoldingRanges(options?: FoldingOptions): FoldingRange[];
     typeText(text: string, options?: TypeTextOptions): boolean;
     private takeBackArrows;
@@ -112,6 +118,8 @@ export declare class DocumentModel {
     private editLines;
     private editSource;
     private isUnclosedBrace;
+    private scriptSource;
+    private scriptBracketIndex;
     private bracketIndex;
     private deleteCharacter;
     private unindent;

package/dist/document.js

@@ -1,8 +1,9 @@
+import { scriptSource } from './script-source.js';
 import { CloserTracker } from './closer-tracker.js';
 import { planBlockComment, planLineComments } from './comments.js';
 import { planEnter } from './enter.js';
 import { planAutoIndent, planJoinLines, planToggleCase, properIndent, spacingBetween } from './line-commands.js';
-import { mapOffset } from './offsets.js';
+import { mapOffset, offsetMapper } from './offsets.js';
 import { planPaste } from './paste.js';
 import { isPlainText, vueRegionAt } from './languages.js';
 import { blockFolds } from './block-folds.js';
@@ -12,8 +13,8 @@ import { rangeOf, whitespaceOf } from './line-text.js';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.js';
 import { scanBrackets } from './brackets.js';
 import { hasSmartSemicolon, isPhp } from './lexical.js';
-import { clampInteger, TextRope } from './rope.js';
-import { findMatches, replacementText, splitsSurrogate } from './search.js';
+import { clampInteger, TextRope, ROPE_CHUNK_SIZE } from './rope.js';
+import { findMatches, findMatchFrom, replacementText, splitsSurrogate } from './search.js';
 import { dedupeFoldingRanges, deriveFoldingRanges, indentationColumn, scanStructure, tabWidth } from './structure.js';
 import { TypingContexts } from './typing-context.js';
 import { isHumpBoundary, isWordBoundary } from './words.js';
@@ -238,6 +239,7 @@ export class DocumentModel {
     occurrencesExhausted = false;
     closers = new CloserTracker();
     bracketCache;
+    scriptCache;
     constructor(text = '') {
         this.rope = TextRope.from(text);
         this.textCache = { text };
@@ -326,21 +328,31 @@ export class DocumentModel {
         }
         const unique = this.validateEdits(edits);
         const changed = unique.filter((edit) => changesText(this.rope, edit));
-        let next = this.rope;
-        for (let index = changed.length - 1; index >= 0; index--) {
-            const edit = changed[index];
-            next = next.replace(edit.from, edit.to, edit.text);
+        // Sparse edits keep structural sharing; dense edits avoid rescanning a leaf for each replacement.
+        const rebuild = changed.length >= 256 && changed.length * ROPE_CHUNK_SIZE >= this.rope.length;
+        let next = rebuild ? this.rope.rebuild(changed) : this.rope;
+        if (!rebuild) {
+            for (let index = changed.length - 1; index >= 0; index--) {
+                const edit = changed[index];
+                next = next.replace(edit.from, edit.to, edit.text);
+            }
         }
-        const nextSelections = options.selections ??
-            this.selections.map((selection) => ({ anchor: mapOffset(selection.anchor, unique), head: mapOffset(selection.head, unique) }));
+        const map = offsetMapper(unique);
+        const at = (position) => {
+            const line = next.lineBounds(position.line);
+            return offsetIn(next, line.start + clampInteger(position.column, line.end - line.start));
+        };
         // Several edits can cancel each other out, like moving a character and moving it back.
         const unchanged = next === this.rope || (changed.length > 1 && next.length === this.rope.length && next.equalsRange(this.rope, changed[0].from, changed.at(-1).to));
         if (unchanged) {
             if (options.selections) {
-                this.setSelections(nextSelections);
+                this.setSelections(options.selections);
             }
             return false;
         }
+        const nextSelections = options.selections ??
+            options.selectionPositions?.map((selection) => ({ anchor: at(selection.anchor), head: at(selection.head) })) ??
+            this.selections.map((selection) => ({ anchor: map(selection.anchor), head: map(selection.head) }));
         const before = this.state();
         const firstLine = this.rope.lineAt(changed[0].from);
         const previous = this.rope;
@@ -354,11 +366,13 @@ export class DocumentModel {
         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);
-        if (options.historyGroup &&
+        const joinsGroup = options.historyGroup &&
             this.groupOpen &&
             last?.group === options.historyGroup &&
             last.after.rope === before.rope &&
-            sameSelections(last.after.selections, before.selections)) {
+            sameSelections(last.after.selections, before.selections);
+        const joinsPrevious = options.joinPrevious === true && last !== undefined && last.after.rope === before.rope;
+        if (last !== undefined && (joinsGroup || joinsPrevious)) {
             last.after = after;
             last.changes.push(changes);
         }
@@ -368,9 +382,9 @@ export class DocumentModel {
         if (this.undoStack.length > historyLimit) {
             this.undoStack.shift();
         }
-        this.groupOpen = Boolean(options.historyGroup);
+        this.groupOpen = Boolean(options.historyGroup) && !joinsPrevious;
         this.redoStack = [];
-        this.emit([changes], options.source ?? 'external', () => editsOf(previous, changed));
+        this.emit([changes], options.source ?? 'external', () => (rebuild ? stretchEdits(previous, next, [changes]) : editsOf(previous, changed)), options.typed);
         return true;
     }
     /* Replaces everything as one undoable external edit. */
@@ -408,11 +422,7 @@ export class DocumentModel {
     }
     /* Includes a match that starts at `from`, or ends there when searching backwards. */
     findNext(query, from = this.selections.at(-1).head, options = {}) {
-        const matches = this.find(query, options);
-        const offset = clampInteger(from, this.rope.length);
-        const ordered = options.backwards ? matches.reverse() : matches;
-        const found = ordered.find((match) => (options.backwards ? match.to <= offset : match.from >= offset));
-        return found ?? (options.wrap === false ? null : (ordered[0] ?? null));
+        return findMatchFrom(this.getText(), query, this.revision, from, options);
     }
     /* Refuses a match from an earlier revision, or one whose text no longer sits there. */
     replace(match, replacement, options = {}) {
@@ -433,14 +443,31 @@ export class DocumentModel {
         if (options.expectedRevision !== undefined && options.expectedRevision !== this.revision) {
             return 0;
         }
-        const matches = this.find(query, options);
+        return this.replaceMatches(this.find(query, options), replacement, options);
+    }
+    /* Commits retained search results as one undo step; one stale result refuses the entire batch. */
+    replaceMatches(matches, replacement, options = {}) {
+        const revision = this.revision;
+        if (matches.length === 0 ||
+            (options.expectedRevision !== undefined && options.expectedRevision !== revision) ||
+            matches.some((match) => match.revision !== revision || this.slice(match.from, match.to) !== match.text)) {
+            return 0;
+        }
+        const ranges = new Set();
+        for (const match of matches) {
+            const key = `${match.from}:${match.to}`;
+            if (ranges.has(key)) {
+                throw new RangeError('Search matches must have unique ranges.');
+            }
+            ranges.add(key);
+        }
         const text = this.getText();
         const edits = matches.map((match) => ({
             from: match.from,
             to: match.to,
             text: replacementText(text, match, replacement, options.literal, options.preserveCase)
         }));
-        return this.applyEdits(edits, { source: 'command', ...options }) ? matches.length : 0;
+        return this.applyEdits(edits, { source: 'command', ...options, expectedRevision: revision }) ? matches.length : 0;
     }
     getFoldingRanges(options = {}) {
         const ranges = options.brackets === false && options.comments === false ? [] : this.structure();
@@ -661,10 +688,12 @@ export class DocumentModel {
         const arrow = text === '-' && input.smartArrow && from === to;
         const needsContext = text.length === 1 && (/[()[\]{}'"`<]/.test(text) || (text === ';' && smartSemicolon) || arrow);
         const context = needsContext ? this.typingContext(from, language) : undefined;
-        if (arrow && context?.mode === 'code' && context.word !== 'control-close' && this.endsOperand(from)) {
+        if (arrow && context?.mode === 'code' && context.embedded === undefined && context.word !== 'control-close' && this.endsOperand(from)) {
             return { from, to, text, anchor: 1, head: 1, arrow: true };
         }
-        const insideQuote = context && (context.mode === 'quote' || context.mode === 'template') && context.quote === text && !context.escaped;
+        const insideQuote = context &&
+            (((context.mode === 'quote' || context.mode === 'template') && context.quote === text && !context.escaped) ||
+                (context.mode === 'html' && context.markup === 'value' && context.markupQuote === text));
         if (pairing && from === to && after === text && (quote ? insideQuote : context?.mode === 'code' && context.bracket?.close === text)) {
             return { from, to, text: '', anchor: 1, head: 1, skip: true };
         }
@@ -736,9 +765,13 @@ export class DocumentModel {
         return { from: line.start, to: offset, text: indent + closer, anchor: indent.length + 1, head: indent.length + 1 };
     }
     shouldClosePair(offset, opener, after, context, input) {
+        if (context?.mode === 'html') {
+            return context.markup === 'equals' && (opener === '"' || opener === "'") && (!after || /[\s>/]/u.test(after));
+        }
         const interpolation = this.isInterpolation(offset, opener, context);
         const quote = isQuote(opener);
-        const followedByTerminator = quote ? !identifier.test(after) && after !== opener : !after || /[\s)\]}>,;:]/u.test(after);
+        const scriptEnd = context?.embedded !== undefined && /^<\/script(?=[\s/>]|$)/i.test(this.slice(offset, offset + 9));
+        const followedByTerminator = quote ? !identifier.test(after) && after !== opener : !after || scriptEnd || /[\s)\]}>,;:]/u.test(after);
         if (context?.mode !== 'code' && !interpolation) {
             return false;
         }
@@ -751,14 +784,22 @@ export class DocumentModel {
                 !this.escaped(offset) &&
                 !this.completesTripleQuote(offset, opener, input.language));
         }
-        return !this.hasMatch(offset, opener, input.language);
+        return !this.hasMatch(offset, opener, input.language, context);
     }
     /* The third quote of a Python docstring opener is typed as it is, since the pair that came before it is the empty string. */
     completesTripleQuote(offset, quote, language) {
         return /^(python|py)$/i.test(language) && quote !== '`' && this.slice(offset - 2, offset) === quote + quote;
     }
     /* Whether the bracket just typed at `offset` would find its closer in the text that already follows it. */
-    hasMatch(offset, opener, language) {
+    hasMatch(offset, opener, language, context) {
+        if (context?.embedded === 'javascript' && context.embedStart !== undefined) {
+            const source = this.scriptSource(context.embedStart, matchScanLimit).text;
+            if (source === undefined) {
+                return false;
+            }
+            const at = offset - context.embedStart;
+            return scanBrackets(source.slice(0, at) + opener + source.slice(at), 'javascript').pairs.has(at);
+        }
         if (this.rope.length > matchScanLimit) {
             return false;
         }
@@ -1277,7 +1318,7 @@ export class DocumentModel {
         if (sorted.some((current, index) => index > 0 && current.from < sorted[index - 1].to)) {
             plans = plan(false);
         }
-        return this.applySelectionEdits(plans.map((entry) => ({ from: entry.from, to: entry.to, text: entry.text, anchor: entry.caret, head: entry.caret })), { source: 'command' });
+        return this.applySelectionEdits(plans.map((entry) => ({ from: entry.from, to: entry.to, text: entry.text, anchor: entry.caret, head: entry.caret })), { source: 'command', typed: mode === 'enter' });
     }
     /* A line of its own above each caret's line, at the indentation of its text. */
     startNewLineBefore(unit) {
@@ -1329,7 +1370,8 @@ export class DocumentModel {
      * it, which it took from that block. Such a closer sits shallower than the brace's line and leaves an opener before it unmatched.
      */
     isUnclosedBrace(offset, language) {
-        const index = this.bracketIndex(language);
+        const context = isPhp(language) ? this.typingContext(offset, language) : undefined;
+        const index = context?.embedded === 'javascript' && context.embedStart !== undefined ? this.scriptBracketIndex(context.embedStart) : this.bracketIndex(language);
         if (index === undefined) {
             return false;
         }
@@ -1343,6 +1385,39 @@ export class DocumentModel {
         }
         return [...index.unmatched].some((at) => at < offset && this.rope.charAt(at) === '{');
     }
+    scriptSource(start, limit) {
+        if (this.scriptCache?.revision !== this.revision) {
+            this.scriptCache = { revision: this.revision, sources: new Map() };
+        }
+        const cached = this.scriptCache.sources.get(start);
+        if (cached !== undefined && (cached.text !== undefined || cached.limit >= limit)) {
+            return cached.text !== undefined && cached.text.length > limit ? { limit } : cached;
+        }
+        const end = Math.min(this.rope.length, start + limit + 11);
+        let work = bracketScanLimit;
+        const prepared = scriptSource(this.slice(start, end), start, end === this.rope.length, (at) => {
+            const position = this.positionAt(at);
+            work -= position.column + 1;
+            return work < 0 ? null : this.typingContext(at, 'php');
+        });
+        const result = { limit, text: prepared !== undefined && prepared.length <= limit ? prepared : undefined };
+        this.scriptCache.sources.set(start, result);
+        return result;
+    }
+    scriptBracketIndex(start) {
+        const source = this.scriptSource(start, bracketScanLimit);
+        if (source.text === undefined) {
+            return undefined;
+        }
+        if (source.index === undefined) {
+            const index = scanBrackets(source.text, 'javascript');
+            source.index = {
+                pairs: new Map([...index.pairs].map(([from, to]) => [from + start, to + start])),
+                unmatched: new Set([...index.unmatched].map((at) => at + start))
+            };
+        }
+        return source.index;
+    }
     /* Undefined for a document too large to scan on every Enter. */
     bracketIndex(language) {
         if (this.rope.length > bracketScanLimit) {
@@ -1418,6 +1493,10 @@ export class DocumentModel {
             return false;
         }
         const context = this.typingContext(offset - 1, language);
+        if (context.mode === 'html' && context.markup === 'equals' && (opener === '"' || opener === "'")) {
+            const inside = this.typingContext(offset, language);
+            return inside.mode === 'html' && inside.markup === 'value' && inside.markupQuote === opener;
+        }
         return context.mode === 'code' || this.isInterpolation(offset - 1, opener, context);
     }
     /* Backspace inside the indentation of a line goes back to the previous tab stop, and at the start of a line joins it with the one above. */
@@ -1819,11 +1898,14 @@ export class DocumentModel {
         this.emit(changes, 'command', () => stretchEdits(previous, state.rope, changes));
     }
     /* `contentEdits` is worked out when a listener asks, since most listeners never do and a restore of a large text would otherwise read all of it. */
-    emit(changes, source, contentEdits) {
+    emit(changes, source, contentEdits, typed) {
         const snapshot = this.getSnapshot();
         if (changes) {
             snapshot.changes = changes.map((transaction) => transaction.map((change) => ({ ...change })));
             snapshot.source = source;
+            if (typed) {
+                snapshot.typed = true;
+            }
             if (contentEdits) {
                 let edits;
                 Object.defineProperty(snapshot, 'contentEdits', { get: () => (edits ??= contentEdits()), enumerable: true });

package/dist/edit-regions.d.ts

@@ -0,0 +1,6 @@
+import type { EditSource } from './edit-source.ts';
+import { type EditRegion } from './languages.ts';
+export type EditRegions = (line: number, offset?: number) => EditRegion | null;
+export declare function phpLiteralAt(source: EditSource, offset: number): boolean;
+export declare function phpTagAt(source: EditSource, offset: number): boolean;
+export declare function editRegions(source: EditSource, language: string): EditRegions;

package/dist/edit-regions.js

@@ -0,0 +1,87 @@
+import { vueRegionAt } from './languages.js';
+import { hasJsx, jsxChildren } from './markup-regions.js';
+const SCAN_LIMIT = 2_000_000;
+export function phpLiteralAt(source, offset) {
+    const context = source.context(offset);
+    return context.mode === 'heredoc' || context.mode === 'quote' || (context.embedded !== undefined && context.mode === 'template');
+}
+export function phpTagAt(source, offset) {
+    const context = source.context(offset);
+    return context.mode === 'html' && (context.markup === 'tag' || context.markup === 'equals' || context.markup === 'value');
+}
+function firstContent(source, line) {
+    const bounds = source.line(line);
+    return bounds.start + bounds.text.length - bounds.text.trimStart().length;
+}
+function mixedPhpLine(source, line) {
+    const bounds = source.line(line);
+    let work = SCAN_LIMIT;
+    for (const match of bounds.text.matchAll(/<\?(?:php\b|=)|\?>/g)) {
+        work -= bounds.text.length + 1;
+        if (work < 0) {
+            return true;
+        }
+        const at = bounds.start + match.index;
+        const context = source.context(at);
+        const { mode, embedded } = context;
+        if (match[0] === '?>') {
+            if (mode !== 'html' && embedded === undefined) {
+                return true;
+            }
+        }
+        else if (mode === 'html' || embedded !== undefined || (mode === 'code' && at === firstContent(source, line))) {
+            return true;
+        }
+    }
+    return false;
+}
+export function editRegions(source, language) {
+    const id = language.toLowerCase();
+    const end = source.line(source.lineCount - 1).end;
+    if (id === 'vue') {
+        return (line) => (/^<\/?(?:template|script|style)\b/.test(source.line(line).text) ? 'mixed' : vueRegionAt((index) => source.line(index).text, line));
+    }
+    if (hasJsx(id)) {
+        let children;
+        return (line, offset) => {
+            if (end > SCAN_LIMIT) {
+                return null;
+            }
+            children ??= jsxChildren(source.slice(0, end));
+            return children(offset ?? firstContent(source, line)) ? 'jsx' : null;
+        };
+    }
+    if (id === 'php') {
+        return (line, offset) => {
+            const bounds = source.line(line);
+            if (offset === undefined &&
+                (phpLiteralAt(source, bounds.start) ||
+                    phpLiteralAt(source, bounds.end) ||
+                    phpTagAt(source, bounds.start) ||
+                    phpTagAt(source, bounds.end) ||
+                    mixedPhpLine(source, line))) {
+                return 'mixed';
+            }
+            const at = offset ?? firstContent(source, line);
+            const context = source.context(at);
+            if (phpTagAt(source, at)) {
+                return 'mixed';
+            }
+            if (context.mode !== 'html' && context.embedded === undefined) {
+                return null;
+            }
+            if (context.markup === 'comment' || (offset === undefined && source.context(bounds.end).markup === 'comment')) {
+                return 'mixed';
+            }
+            if (context.markup === 'raw') {
+                const closing = /^<\/(script|style|textarea|title)(?=[\s/>]|$)/i.exec(source.slice(at, at + 11));
+                // The closing tag belongs to markup, while the preceding raw text keeps its syntax.
+                if (closing?.[1]?.toLowerCase() !== context.element) {
+                    return context.element === 'script' || context.element === 'style' ? context.element : 'mixed';
+                }
+            }
+            return 'template';
+        };
+    }
+    return () => null;
+}