svelte-streamdown 4.0.0 → 4.1.0

package/dist/utils/parse-incomplete-markdown.js

@@ -1,3 +1,4 @@
+import { trackFence } from './fence.js';
 export class IncompleteMarkdownParser {
     plugins = [];
     state = {
@@ -21,8 +22,7 @@ export class IncompleteMarkdownParser {
             currentLine: 0,
             context: 'normal',
             blockingContexts: new Set(),
-            lineContexts: [],
-            fenceInfo: undefined
+            lineContexts: []
         };
         let result = text;
         // Execute preprocess hooks for all plugins
@@ -98,14 +98,29 @@ export class IncompleteMarkdownParser {
     // Create default plugins that replicate the original handler functions
     static createDefaultPlugins() {
         return [
+            {
+                // Runs first: in a list item a '>' before a number is a comparison
+                // ('- > 25: rich'), but marked reads it as a nested blockquote. Escaping it
+                // keeps the text, and the escape renders as a plain '>' (4fffb9f).
+                // `pattern` is only a cheap gate — a line whose first non-space character is
+                // not a list marker can never match, and bails on that one character.
+                name: 'comparisonOperator',
+                pattern: /^\s*[-*+\d]/,
+                skipInBlockTypes: ['code', 'math'],
+                handler: ({ line }) => {
+                    const match = listItemComparison.exec(line);
+                    return match ? `${match[1]}\\>${line.slice(match[0].length)}` : line;
+                }
+            },
             // Block-level plugin that manages blocking contexts
             {
                 name: 'contextManager',
                 preprocess: ({ text }) => {
                     // Pre-scan the entire text to establish blocking contexts
                     const lines = text.split('\n');
-                    let inCodeBlock = false;
+                    let fence = null;
                     let inMathBlock = false;
+                    let mathCloser = '$$';
                     let inCenterBlock = false;
                     let inRightBlock = false;
                     let centerOpenLine = -1;
@@ -114,13 +129,23 @@ export class IncompleteMarkdownParser {
                     const lineContexts = [];
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];
-                        // Check for block boundaries (fences may be quoted inside blockquotes/alerts: "> ```")
-                        const fenceLine = line.replace(/^[ \t]*(?:>[ \t]*)*/, '');
-                        if (fenceLine.startsWith('```') || fenceLine.startsWith('~~~')) {
-                            inCodeBlock = !inCodeBlock;
+                        // Check for block boundaries. Fences may be quoted inside
+                        // blockquotes/alerts ("> ```"); trackFence is the same CommonMark
+                        // scanner the `incomplete` signal uses, so the two cannot drift.
+                        fence = trackFence(line, fence);
+                        const inCodeBlock = fence !== null;
+                        // A math block opens with '$$' or a lone '\\[' and closes with the
+                        // same delimiter it opened with, so '$' inside '\\[ … \\]' is literal.
+                        const trimmed = line.trim();
+                        const isDollarFence = trimmed.startsWith('$$') && !trimmed.includes('$$', 2);
+                        if (!inMathBlock) {
+                            if (isDollarFence || trimmed === '\\[') {
+                                inMathBlock = true;
+                                mathCloser = isDollarFence ? '$$' : '\\]';
+                            }
                         }
-                        if (line.trim().startsWith('$$') && !line.trim().includes('$$', 2)) {
-                            inMathBlock = !inMathBlock;
+                        else if (mathCloser === '$$' ? isDollarFence : trimmed === '\\]') {
+                            inMathBlock = false;
                         }
                         if (line.trim() === '[center]') {
                             inCenterBlock = true;
@@ -145,7 +170,7 @@ export class IncompleteMarkdownParser {
                     }
                     // Set the final blocking contexts (for postprocessing)
                     const finalContexts = new Set();
-                    if (inCodeBlock)
+                    if (fence)
                         finalContexts.add('code');
                     if (inMathBlock)
                         finalContexts.add('math');
@@ -160,7 +185,9 @@ export class IncompleteMarkdownParser {
                         text: text, // Don't modify text in preprocess
                         state: {
                             blockingContexts: finalContexts,
-                            lineContexts
+                            lineContexts,
+                            mathCloser,
+                            openFence: fence
                         }
                     };
                 },
@@ -169,10 +196,20 @@ export class IncompleteMarkdownParser {
                     // Close inner blocks (code/math) before alignment wrappers.
                     let result = text;
                     if (state.blockingContexts.has('code')) {
-                        result += '\n```';
+                        // Close with the fence that was opened: a '~~~' block is not closed by
+                        // '```', and a longer run needs a closer at least as long.
+                        const fence = state.openFence;
+                        result += '\n' + (fence ? fence.char.repeat(fence.length) : '```');
                     }
                     if (state.blockingContexts.has('math')) {
-                        result += '\n$$';
+                        if (state.mathCloser === '\\]') {
+                            result += '\n\\]';
+                        }
+                        else {
+                            // The first half of the closing '$$' may already have arrived: adding a
+                            // whole '\n$$' would leave a stray '$' inside the math and '$$' after it.
+                            result += result.endsWith('$') && !result.endsWith('$$') ? '$' : '\n$$';
+                        }
                     }
                     if (state.blockingContexts.has('center')) {
                         result += '\n[/center]';
@@ -195,6 +232,8 @@ export class IncompleteMarkdownParser {
                     const tripleAsterisks = (line.match(/\*\*\*/g) || []).length;
                     if (tripleAsterisks % 2 === 1) {
                         const lastTripleAsteriskIndex = line.lastIndexOf('***');
+                        if (isWithinCompleteInlineCode(line, lastTripleAsteriskIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastTripleAsteriskIndex);
                         if (isEndingWithTripleAsterisk) {
                             return line.substring(0, lastTripleAsteriskIndex);
@@ -222,6 +261,8 @@ export class IncompleteMarkdownParser {
                     if (doubleAsteriskMatches % 2 === 1) {
                         const isEndingWithDoubleAsterisk = line.endsWith('**');
                         const lastDoubleAsteriskIndex = line.lastIndexOf('**');
+                        if (isWithinCompleteInlineCode(line, lastDoubleAsteriskIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleAsteriskIndex);
                         if (isEndingWithDoubleAsterisk) {
                             return line.substring(0, lastDoubleAsteriskIndex);
@@ -248,6 +289,8 @@ export class IncompleteMarkdownParser {
                     if (underscorePairs % 2 === 1) {
                         const isEndingWithDoubleUnderscore = line.endsWith('__');
                         const lastDoubleUnderscoreIndex = line.lastIndexOf('__');
+                        if (isWithinCompleteInlineCode(line, lastDoubleUnderscoreIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleUnderscoreIndex);
                         if (isEndingWithDoubleUnderscore) {
                             return line.substring(0, lastDoubleUnderscoreIndex);
@@ -270,6 +313,8 @@ export class IncompleteMarkdownParser {
                     if (tildePairs % 2 === 1) {
                         const isEndingWithDoubleTilde = line.endsWith('~~');
                         const lastDoubleTildeIndex = line.lastIndexOf('~~');
+                        if (isWithinCompleteInlineCode(line, lastDoubleTildeIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleTildeIndex);
                         // Only complete if there's content after the tildes
                         const contentAfterTildes = line.substring(lastDoubleTildeIndex + 2, endOfCellOrLine);
@@ -288,45 +333,58 @@ export class IncompleteMarkdownParser {
             },
             {
                 name: 'singleAsteriskItalic',
-                pattern: /[\s\S]*/,
+                pattern: /\*/,
                 skipInBlockTypes: ['code', 'math'],
                 handler: ({ line }) => {
                     if (line.trim() === '***') {
                         return line;
                     }
+                    // '\(w^{*}\)' and '$w^{*}$' are formulas, not half-open emphasis (8093f2a).
+                    const mathy = mathDelimiter.test(line);
                     // Inline countSingleAsterisks logic
                     let singleAsterisks = 0;
+                    let lastSingleAsterisk = -1;
                     for (let i = 0; i < line.length; i++) {
                         if (line[i] === '*') {
                             const prevChar = i > 0 ? line[i - 1] : '';
                             const nextChar = i < line.length - 1 ? line[i + 1] : '';
-                            let lineStartIndex = i;
-                            for (let j = i - 1; j >= 0; j--) {
-                                if (line[j] === '\n') {
-                                    lineStartIndex = j + 1;
-                                    break;
-                                }
-                                if (j === 0) {
-                                    lineStartIndex = 0;
-                                    break;
-                                }
+                            // Whitespace on both sides means arithmetic ('5 * 0') or a bare list
+                            // marker, never an emphasis delimiter (c347b53).
+                            if (isSpaceOrEdge(prevChar) && isSpaceOrEdge(nextChar)) {
+                                continue;
                             }
-                            const beforeAsterisk = line.substring(lineStartIndex, i);
-                            if (beforeAsterisk.trim() === '' && (nextChar === ' ' || nextChar === '\t')) {
+                            if (mathy && isWithinMathBlock(line, i)) {
+                                continue;
+                            }
+                            if (isWithinCompleteInlineCode(line, i)) {
                                 continue;
                             }
                             if (prevChar !== '*' && nextChar !== '*') {
                                 singleAsterisks++;
+                                lastSingleAsterisk = i;
                             }
                         }
                     }
                     if (singleAsterisks % 2 === 1) {
+                        // The dangling asterisk is the last counted one. If it cannot OPEN
+                        // emphasis (nothing or whitespace after it) it is an intraword or
+                        // trailing closer — '*foo*bar*' is literal, not half of '*foo*bar**'
+                        // (9f96409).
+                        if (isSpaceOrEdge(line[lastSingleAsterisk + 1] ?? '')) {
+                            return line;
+                        }
                         // Inline findFirstSingleAsterisk logic
                         let firstSingleAsteriskIndex = -1;
                         for (let i = 0; i < line.length; i++) {
                             if (line[i] === '*' && line[i - 1] !== '*' && line[i + 1] !== '*') {
                                 const prevChar = i > 0 ? line[i - 1] : '';
                                 const nextChar = i < line.length - 1 ? line[i + 1] : '';
+                                if (isSpaceOrEdge(prevChar) && isSpaceOrEdge(nextChar))
+                                    continue;
+                                if (mathy && isWithinMathBlock(line, i))
+                                    continue;
+                                if (isWithinCompleteInlineCode(line, i))
+                                    continue;
                                 if (/\w/.test(prevChar) && /\w/.test(nextChar))
                                     continue;
                                 if (/\w/.test(prevChar) && !/\s/.test(prevChar))
@@ -378,11 +436,14 @@ export class IncompleteMarkdownParser {
             },
             {
                 name: 'singleUnderscoreItalic',
-                pattern: /[\s\S]*/,
+                pattern: /_/,
                 skipInBlockTypes: ['code', 'math'],
                 handler: ({ line }) => {
-                    // Inline countSingleUnderscores logic
+                    // Inline countSingleUnderscores logic. The first counted underscore is
+                    // also the one findFirstSingleUnderscore used to look for in a second
+                    // identical pass, so it is picked up here.
                     let singleUnderscores = 0;
+                    let firstSingleUnderscoreIndex = -1;
                     for (let i = 0; i < line.length; i++) {
                         if (line[i] === '_') {
                             const prevChar = i > 0 ? line[i - 1] : '';
@@ -391,6 +452,8 @@ export class IncompleteMarkdownParser {
                                 continue;
                             if (isWithinMathBlock(line, i))
                                 continue;
+                            if (isWithinCompleteInlineCode(line, i))
+                                continue;
                             if (prevChar &&
                                 nextChar &&
                                 /[\p{L}\p{N}_]/u.test(prevChar) &&
@@ -399,34 +462,14 @@ export class IncompleteMarkdownParser {
                             }
                             if (prevChar !== '_' && nextChar !== '_') {
                                 singleUnderscores++;
+                                if (firstSingleUnderscoreIndex === -1)
+                                    firstSingleUnderscoreIndex = i;
                             }
                         }
                     }
                     if (singleUnderscores % 2 === 1) {
-                        // Inline findFirstSingleUnderscore logic
-                        let firstSingleUnderscoreIndex = -1;
-                        for (let i = 0; i < line.length; i++) {
-                            if (line[i] === '_' &&
-                                line[i - 1] !== '_' &&
-                                line[i + 1] !== '_' &&
-                                line[i - 1] !== '\\' &&
-                                !isWithinMathBlock(line, i)) {
-                                const prevChar = i > 0 ? line[i - 1] : '';
-                                const nextChar = i < line.length - 1 ? line[i + 1] : '';
-                                if (prevChar &&
-                                    nextChar &&
-                                    /[\p{L}\p{N}_]/u.test(prevChar) &&
-                                    /[\p{L}\p{N}_]/u.test(nextChar)) {
-                                    continue;
-                                }
-                                firstSingleUnderscoreIndex = i;
-                                break;
-                            }
-                        }
-                        if (firstSingleUnderscoreIndex !== -1) {
-                            const endOfCellOrLine = findEndOfCellOrLineContaining(line, firstSingleUnderscoreIndex);
-                            return line.substring(0, endOfCellOrLine) + '_' + line.substring(endOfCellOrLine);
-                        }
+                        const endOfCellOrLine = findEndOfCellOrLineContaining(line, firstSingleUnderscoreIndex);
+                        return line.substring(0, endOfCellOrLine) + '_' + line.substring(endOfCellOrLine);
                     }
                     return line;
                 }
@@ -450,11 +493,17 @@ export class IncompleteMarkdownParser {
                     }
                     if (singleTildes % 2 === 1) {
                         const lastTildeIndex = line.lastIndexOf('~');
-                        if (lastTildeIndex !== -1 && !isWithinMathBlock(line, lastTildeIndex)) {
+                        if (lastTildeIndex !== -1 &&
+                            !isWithinMathBlock(line, lastTildeIndex) &&
+                            !isWithinCompleteInlineCode(line, lastTildeIndex)) {
                             const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastTildeIndex);
-                            // Only complete if there's content after the tilde
                             const contentAfterTilde = line.substring(lastTildeIndex + 1, endOfCellOrLine);
-                            if (contentAfterTilde.trim().length > 0) {
+                            // A subscript is '~text~' with no whitespace inside (same rule as the
+                            // lexer), and a digit before the tilde means a range like '20~25°C':
+                            // closing those would manufacture a subscript nobody typed (716a5f0).
+                            if (contentAfterTilde.length > 0 &&
+                                !/\s/.test(contentAfterTilde) &&
+                                !/\d/.test(line[lastTildeIndex - 1] ?? '')) {
                                 return line.substring(0, endOfCellOrLine) + '~' + line.substring(endOfCellOrLine);
                             }
                         }
@@ -485,50 +534,86 @@ export class IncompleteMarkdownParser {
                     if (line.includes('](')) {
                         return line;
                     }
-                    // Collect unescaped opening brackets without a matching closing bracket
-                    const unclosedPositions = [];
-                    for (let i = 0; i < line.length; i++) {
-                        if (line[i] === '[' && (i === 0 || line[i - 1] !== '\\')) {
-                            // Check if this bracket has a matching closing bracket later in the line
-                            if (line.indexOf(']', i + 1) === -1) {
-                                unclosedPositions.push(i);
-                            }
+                    // A '[' is unclosed exactly when no ']' follows it, so nothing before the
+                    // last ']' can be: one lastIndexOf replaces an indexOf per bracket.
+                    const lastClose = line.lastIndexOf(']');
+                    const unclosed = [];
+                    for (let i = lastClose + 1; i < line.length; i++) {
+                        // Inside a math span a bracket is notation, not a citation opener:
+                        // '\\(a[b\\)' must not gain a ']' at the end of the line.
+                        if (line[i] === '[' && line[i - 1] !== '\\' && mathContextAt(line, i) === 'none') {
+                            unclosed.push(i);
                         }
                     }
-                    // Close every unclosed citation bracket (right to left so indices stay
-                    // valid). Brackets that look like incomplete images (`![`), footnotes
-                    // (`[^`), link text containing markdown formatting, table-cell content,
-                    // or a trailing bracket preceded by a completed `[...]` pair (evidence
-                    // of an in-progress link) are left for the dedicated plugins
-                    // (footnoteRef, linksAndImages).
-                    let result = line;
-                    for (let k = unclosedPositions.length - 1; k >= 0; k--) {
-                        const pos = unclosedPositions[k];
-                        const endOfCellOrLine = findEndOfCellOrLineContaining(result, pos);
-                        const content = result.substring(pos + 1, endOfCellOrLine);
-                        const isImage = pos > 0 && result[pos - 1] === '!';
-                        const isFootnote = content.startsWith('^');
-                        const hasFormatting = /[*~`_]/.test(content);
-                        const isTableCell = endOfCellOrLine < result.length && result[endOfCellOrLine] === '|';
-                        const hasPriorCompletedPair = /\[[^\]]*\]/.test(line.substring(0, pos));
-                        if (isImage || isFootnote || hasFormatting || isTableCell || hasPriorCompletedPair) {
+                    if (unclosed.length === 0)
+                        return line;
+                    // A completed `[...]` pair in front of them is evidence of an in-progress
+                    // link, left to linksAndImages. No ']' can follow the first unclosed
+                    // bracket, so that answer is the same for all of them: decided once.
+                    let sawOpen = false;
+                    for (let i = 0; i < unclosed[0]; i++) {
+                        if (line[i] === ']' && sawOpen)
+                            return line;
+                        sawOpen ||= line[i] === '[';
+                    }
+                    // Close every unclosed citation bracket. Brackets that look like
+                    // incomplete images (`![`), footnotes (`[^`), link text containing
+                    // markdown formatting, or table-cell content are left for the dedicated
+                    // plugins (footnoteRef, linksAndImages). The cell boundary, the
+                    // formatting scan and the citation key all advance monotonically with
+                    // the brackets, so the line is walked a constant number of times.
+                    const insertions = [];
+                    let cellEnd = 0;
+                    let lastFormatting = -1;
+                    let keyStart = 0;
+                    let keyEnd = 0;
+                    for (let k = 0; k < unclosed.length; k++) {
+                        const pos = unclosed[k];
+                        if (cellEnd <= pos) {
+                            cellEnd = findEndOfCellOrLineContaining(line, pos);
+                            lastFormatting = -1;
+                            for (let i = pos + 1; i < cellEnd; i++) {
+                                if (formattingChars.has(line[i]))
+                                    lastFormatting = i;
+                            }
+                        }
+                        const isImage = pos > 0 && line[pos - 1] === '!';
+                        const isFootnote = line[pos + 1] === '^';
+                        const isTableCell = cellEnd < line.length && line[cellEnd] === '|';
+                        if (isImage || isFootnote || lastFormatting > pos || isTableCell) {
                             continue;
                         }
-                        if (k === unclosedPositions.length - 1) {
+                        if (k === unclosed.length - 1) {
                             // Last bracket: close at end of cell/line (keeps multi-key citations together)
-                            result =
-                                result.substring(0, endOfCellOrLine) + ']' + result.substring(endOfCellOrLine);
+                            insertions.push(cellEnd);
                         }
                         else {
                             // Earlier brackets: close right after the citation key (first word)
-                            const keyMatch = content.match(/^\s*\S+/);
-                            if (keyMatch) {
-                                const insertAt = pos + 1 + keyMatch[0].length;
-                                result = result.substring(0, insertAt) + ']' + result.substring(insertAt);
-                            }
+                            if (keyStart < pos + 1)
+                                keyStart = pos + 1;
+                            while (keyStart < cellEnd && isSpaceOrEdge(line[keyStart]))
+                                keyStart++;
+                            if (keyEnd < keyStart)
+                                keyEnd = keyStart;
+                            while (keyEnd < cellEnd && !isSpaceOrEdge(line[keyEnd]))
+                                keyEnd++;
+                            if (keyEnd > keyStart)
+                                insertions.push(keyEnd);
                         }
                     }
-                    return result;
+                    if (insertions.length === 0)
+                        return line;
+                    // Offsets are all against the original line and ascending, so the
+                    // closers are spliced in with one join instead of rebuilding the line
+                    // per bracket.
+                    const out = [];
+                    let from = 0;
+                    for (const at of insertions) {
+                        out.push(line.slice(from, at), ']');
+                        from = at;
+                    }
+                    out.push(line.slice(from));
+                    return out.join('');
                 }
             },
             {
@@ -536,6 +621,8 @@ export class IncompleteMarkdownParser {
                 pattern: /\^/,
                 skipInBlockTypes: ['code', 'math'],
                 handler: ({ line }) => {
+                    // An exponent ('\(w^{*}\)', '$E = mc^2$') is not half-open superscript.
+                    const mathy = mathDelimiter.test(line);
                     // Inline countSingleCarets logic
                     let singleCarets = 0;
                     for (let i = 0; i < line.length; i++) {
@@ -543,6 +630,8 @@ export class IncompleteMarkdownParser {
                             const prevChar = i > 0 ? line[i - 1] : '';
                             if (prevChar === '\\')
                                 continue;
+                            if (mathy && isWithinMathBlock(line, i))
+                                continue;
                             if (!isWithinFootnoteRef(line, i))
                                 singleCarets++;
                         }
@@ -550,7 +639,7 @@ export class IncompleteMarkdownParser {
                     if (singleCarets % 2 === 1) {
                         const lastCaretIndex = line.lastIndexOf('^');
                         if (lastCaretIndex !== -1 &&
-                            !isWithinMathBlock(line, lastCaretIndex) &&
+                            !(mathy && isWithinMathBlock(line, lastCaretIndex)) &&
                             !isWithinFootnoteRef(line, lastCaretIndex)) {
                             const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastCaretIndex);
                             // Only complete if there's content after the caret
@@ -580,6 +669,9 @@ export class IncompleteMarkdownParser {
                                 continue;
                             if (nextChar && /\d/.test(nextChar))
                                 continue;
+                            // A '$' shown as code ('`$var`') must not flip the parity (e50b0c4)
+                            if (isWithinCompleteInlineCode(line, i))
+                                continue;
                             singleDollars++;
                         }
                     }
@@ -593,7 +685,8 @@ export class IncompleteMarkdownParser {
                                     prevChar !== '$' &&
                                     nextChar !== '$' &&
                                     nextChar !== '' &&
-                                    !/\d/.test(nextChar)) {
+                                    !/\d/.test(nextChar) &&
+                                    !isWithinCompleteInlineCode(line, i)) {
                                     lastDollarIndex = i;
                                     break;
                                 }
@@ -629,6 +722,27 @@ export class IncompleteMarkdownParser {
                     return line;
                 }
             },
+            {
+                // Same job inlineMath does for '$': a half-streamed '\(x^2' should render
+                // as math rather than flashing a literal escaped paren. A lone '\[' on its
+                // own line is a block opener and is closed by contextManager instead.
+                name: 'latexMath',
+                pattern: /\\[([]/,
+                skipInBlockTypes: ['code', 'math'],
+                handler: ({ line }) => {
+                    const context = mathContextAt(line, line.length);
+                    if (context !== 'inlineLatex' && context !== 'blockLatex')
+                        return line;
+                    const opener = context === 'inlineLatex' ? '\\(' : '\\[';
+                    const openIndex = line.lastIndexOf(opener);
+                    const endOfCellOrLine = findEndOfCellOrLineContaining(line, openIndex);
+                    // Nothing to render yet: leave the bare delimiter for the next chunk.
+                    if (!line.substring(openIndex + 2, endOfCellOrLine).trim())
+                        return line;
+                    const closer = context === 'inlineLatex' ? '\\)' : '\\]';
+                    return line.substring(0, endOfCellOrLine) + closer + line.substring(endOfCellOrLine);
+                }
+            },
             {
                 name: 'descriptionList',
                 pattern: /^(\s*):/,
@@ -654,7 +768,11 @@ export class IncompleteMarkdownParser {
                 handler: ({ line }) => {
                     // Check for incomplete links with URLs: [text](url
                     const urlMatch = line.match(/(!?\[[^\]]*\]\()([^)]*?)$/);
-                    if (urlMatch) {
+                    // An escaped bracket opens nothing — '\[' is LaTeX display math or a
+                    // literal '[', never an incomplete link (8093f2a). Both regexes here are
+                    // anchored to the end of the line, so a guarded match means the line has
+                    // no incomplete link at all.
+                    if (urlMatch && !isEscapedBracket(line, urlMatch)) {
                         const url = urlMatch[2];
                         if (url.length > 0) {
                             // Inline isUrlIncomplete logic
@@ -696,7 +814,7 @@ export class IncompleteMarkdownParser {
                     }
                     // Check for incomplete links without URLs: [text
                     const linkMatch = line.match(/(!?\[)([^\]]*?)$/);
-                    if (linkMatch && !line.includes('](')) {
+                    if (linkMatch && !isEscapedBracket(line, linkMatch) && !line.includes('](')) {
                         const [, openBracket, linkTextWithPossibleBoundary] = linkMatch;
                         // Position of the matched opening bracket (the regex matches the first
                         // bracket that stays unclosed through the end of the line). Using the
@@ -866,6 +984,14 @@ export const parseIncompleteMarkdown = (text) => {
     return defaultParser.parse(text);
 };
 // Utility functions
+// Full test for the comparisonOperator plugin, whose `pattern` only gates it.
+const listItemComparison = /^(\s*(?:[-*+]|\d+[.)]) +)>(?==?\s*\$?\d)/;
+// Emphasis/code markers, as a set so inlineCitation can scan a cell for them
+// without building a substring per bracket.
+const formattingChars = new Set(['*', '~', '`', '_']);
+// The char accessors in the plugins return '' past either end of the line, so an
+// empty string here means "edge of line".
+const isSpaceOrEdge = (char) => !char || /\s/.test(char);
 const findEndOfCellOrLineContaining = (text, position) => {
     let endPos = position;
     while (endPos < text.length && text[endPos] !== '\n' && text[endPos] !== '|') {
@@ -873,47 +999,146 @@ const findEndOfCellOrLineContaining = (text, position) => {
     }
     return endPos;
 };
-const isWithinMathBlock = (text, position) => {
-    let inInlineMath = false;
-    let inBlockMath = false;
-    for (let i = 0; i < text.length && i < position; i++) {
-        if (text[i] === '\\' && text[i + 1] === '$') {
-            i++;
+// End (exclusive) of the complete inline-code span opened by the backtick run at
+// `open`, or -1 when that run is never closed.
+const endOfCodeSpan = (line, open) => {
+    let openEnd = open;
+    while (line.charCodeAt(openEnd) === 96)
+        openEnd++;
+    const runLength = openEnd - open;
+    for (let j = openEnd; j < line.length; j++) {
+        if (line.charCodeAt(j) !== 96)
+            continue;
+        let closeEnd = j;
+        while (line.charCodeAt(closeEnd) === 96)
+            closeEnd++;
+        if (closeEnd - j === runLength)
+            return j + runLength;
+        j = closeEnd - 1;
+    }
+    return -1;
+};
+// The spans are probed at ascending positions along one line (once per marker
+// character in the worst case), so the walk is resumed where it stopped instead
+// of restarted from the line's first backtick — the difference between linear
+// and quadratic on a long line. A query that moves backwards, or onto another
+// line, restarts it. Four scalars: allocating a mask per line instead costs more
+// in GC than the scan it saves.
+let codeLine = '';
+let codePosition = -1;
+let codeOpen = -1;
+let codeEnd = -1;
+let codeUnclosed = false;
+const isWithinCompleteInlineCode = (line, position) => {
+    if (line !== codeLine || position < codePosition) {
+        codeLine = line;
+        codeOpen = line.indexOf('`');
+        codeEnd = codeOpen === -1 ? -1 : endOfCodeSpan(line, codeOpen);
+        // An unterminated run closes nothing, so neither it nor anything after it
+        // is code: completing emphasis inside it is what streaming needs.
+        codeUnclosed = codeOpen !== -1 && codeEnd === -1;
+    }
+    codePosition = position;
+    while (!codeUnclosed && codeOpen !== -1 && position >= codeEnd) {
+        codeOpen = line.indexOf('`', codeEnd);
+        if (codeOpen === -1)
+            break;
+        codeEnd = endOfCodeSpan(line, codeOpen);
+        if (codeEnd === -1)
+            codeUnclosed = true;
+    }
+    return !codeUnclosed && codeOpen !== -1 && position >= codeOpen && position < codeEnd;
+};
+/**
+ * Math delimiters `mathContextAt` reacts to. Testing this first keeps the
+ * per-character scan off the lines — nearly all of them — that cannot be math.
+ */
+const mathDelimiter = /\$|\\[([]/;
+// Same deal as the code-span walk above: one left-to-right fold over the line,
+// resumed rather than replayed from character 0 on every probe. The fold carries
+// the LaTeX states too (8093f2a), so the guards that consult it stay linear on a
+// long line instead of costing an O(n) probe per marker.
+let mathLine = '';
+let mathNext = 0;
+let mathState = 'none';
+/**
+ * The math context a position sits in: `$`/`$$` as before, plus the LaTeX
+ * delimiters the lexer now tokenizes. Inside `\(`/`\[` a `$` is literal, so
+ * dollars are only read when no LaTeX span is open.
+ */
+const mathContextAt = (text, position) => {
+    if (text !== mathLine || position < mathNext) {
+        mathLine = text;
+        mathNext = 0;
+        mathState = 'none';
+    }
+    let i = mathNext;
+    for (; i < text.length && i < position; i++) {
+        if (text[i] === '\\') {
+            const next = text[i + 1];
+            // An escaped backslash consumes both characters, so '\\[' in the source is a
+            // literal backslash then a '[', not an opener. The lexer's tokenizer rejects
+            // it the same way; skipping the pair keeps the two scanners in agreement.
+            if (next === '\\') {
+                i++;
+                continue;
+            }
+            if (next === '$') {
+                i++;
+                continue;
+            }
+            if (mathState === 'none' && (next === '(' || next === '[')) {
+                mathState = next === '(' ? 'inlineLatex' : 'blockLatex';
+                i++;
+                continue;
+            }
+            if ((mathState === 'inlineLatex' && next === ')') ||
+                (mathState === 'blockLatex' && next === ']')) {
+                mathState = 'none';
+                i++;
+                continue;
+            }
             continue;
         }
-        if (text[i] === '$') {
+        if (text[i] === '$' && mathState !== 'inlineLatex' && mathState !== 'blockLatex') {
             if (text[i + 1] === '$') {
-                inBlockMath = !inBlockMath;
+                mathState = mathState === 'blockDollar' ? 'none' : 'blockDollar';
                 i++;
-                inInlineMath = false;
             }
-            else if (!inBlockMath) {
-                inInlineMath = !inInlineMath;
+            else if (mathState !== 'blockDollar') {
+                // '$100' is a price, not an opening delimiter — the same currency rule the
+                // inlineMath counter below and the lexer apply. Without it a single price
+                // on the line would make everything after it look like math.
+                if (mathState === 'none' && /\d/.test(text[i + 1] ?? ''))
+                    continue;
+                mathState = mathState === 'inlineDollar' ? 'none' : 'inlineDollar';
             }
         }
     }
-    return inInlineMath || inBlockMath;
+    mathNext = i;
+    return mathState;
 };
+const isWithinMathBlock = (text, position) => mathContextAt(text, position) !== 'none';
+/**
+ * True when the '[' captured in group 1 (possibly behind a '!') cannot open a
+ * link: it is backslash-escaped, or it sits inside a math span, where brackets
+ * are notation ('\\(a[b\\)') rather than markup.
+ */
+const isEscapedBracket = (line, match) => {
+    const bracketIndex = (match.index ?? 0) + (match[1].startsWith('!') ? 1 : 0);
+    return line[bracketIndex - 1] === '\\' || mathContextAt(line, bracketIndex) !== 'none';
+};
+// Only ever asked about a '^': that caret belongs to a footnote reference when a
+// '[' sits immediately before it and a ']' closes it before any other bracket.
+// (Walking back to the nearest bracket instead is O(line) per caret.)
 const isWithinFootnoteRef = (text, position) => {
-    let openBracketPos = -1;
-    let caretPos = -1;
-    for (let i = position; i >= 0; i--) {
+    if (text[position - 1] !== '[')
+        return false;
+    for (let i = position + 1; i < text.length; i++) {
         if (text[i] === ']')
-            return false;
-        if (text[i] === '^' && caretPos === -1)
-            caretPos = i;
-        if (text[i] === '[') {
-            openBracketPos = i;
+            return true;
+        if (text[i] === '[' || text[i] === '\n')
             break;
-        }
-    }
-    if (openBracketPos !== -1 && caretPos === openBracketPos + 1 && position >= caretPos) {
-        for (let i = position + 1; i < text.length; i++) {
-            if (text[i] === ']')
-                return true;
-            if (text[i] === '[' || text[i] === '\n')
-                break;
-        }
     }
     return false;
 };