svelte-streamdown 4.0.1 → 4.1.1

package/dist/marked/marked-math.js

@@ -4,6 +4,13 @@ const blockRule = /^(\$\$)(?:\n((?:\\[\s\S]|[^\\])+?)\n\1(?:\n|$)|([^$\n]+?)\1(?
 // Inline math: handles both single ($) and double ($$) dollar delimiters
 // Avoids matching currency by checking context and requiring proper content
 const inlineRule = /^(\${1,2})(?!\$)((?:[^$\n]|\\\$)*?)\1(?!\d)/;
+// LaTeX delimiters. LLMs emit these as often as dollars, so they produce the
+// same `math` token: `\(`/`\)` inline, `\[`/`\]` display. Only the block form
+// may span lines; an escaped backslash (`\\(`) is not a delimiter, which the
+// charCode dispatch below rejects before any regex runs.
+const inlineParenRule = /^\\\(([^\n]*?)\\\)/;
+const inlineBracketRule = /^\\\[([^\n]*?)\\\]/;
+const blockBracketRule = /^\\\[([\s\S]+?)\\\](?:\n|$)/;
 // Enhanced currency detection patterns
 const currencyPatterns = {
     // Simple price patterns: $123, $123.45, $1,234.56
@@ -20,6 +27,20 @@ export const markedMath = [
         name: 'math',
         level: 'block',
         tokenizer(src) {
+            if (src.charCodeAt(0) === 92 /* \ */) {
+                if (src.charCodeAt(1) !== 91 /* [ */)
+                    return;
+                const latex = src.match(blockBracketRule);
+                if (!latex)
+                    return;
+                return {
+                    type: 'math',
+                    isInline: false,
+                    displayMode: true,
+                    raw: latex[0],
+                    text: latex[1].trim()
+                };
+            }
             if (src.charCodeAt(0) !== 36 /* $ */)
                 return;
             const match = src.match(blockRule);
@@ -69,7 +90,25 @@ export const markedMath = [
             }
         },
         tokenizer(src) {
-            // inlineRule is anchored on `$`; skip the regex otherwise (see marked-br.ts).
+            // The rules are anchored on their opening delimiter; skip the regex
+            // otherwise (see marked-br.ts) — this runs at every inline scan position.
+            if (src.charCodeAt(0) === 92 /* \ */) {
+                const open = src.charCodeAt(1);
+                // `\\(` is an escaped backslash followed by a paren, never math.
+                const displayMode = open === 91; /* [ */
+                if (!displayMode && open !== 40 /* ( */)
+                    return;
+                const latex = src.match(displayMode ? inlineBracketRule : inlineParenRule);
+                if (!latex)
+                    return;
+                return {
+                    type: 'math',
+                    isInline: true,
+                    displayMode,
+                    raw: latex[0],
+                    text: latex[1].trim()
+                };
+            }
             if (src.charCodeAt(0) !== 36 /* $ */)
                 return;
             const match = src.match(inlineRule);

package/dist/utils/fence.d.ts

@@ -0,0 +1,27 @@
+/**
+ * An open code fence: the character it was opened with, its run length, and
+ * the prefix the opener sat behind (indentation, blockquote markers, a list
+ * marker). The prefix is what a closer's indentation is measured against.
+ */
+export type OpenFence = {
+    char: string;
+    length: number;
+    prefix: string;
+} | null;
+/**
+ * Fence tracking, one line at a time: returns the fence state after `line`.
+ * The completer's block scan and `hasUnclosedFence` both walk with this, so the
+ * "am I inside a fence" answer can never drift between them.
+ */
+export declare const trackFence: (line: string, open: OpenFence) => OpenFence;
+/**
+ * The line that closes `open`, placed at the opener's depth so it closes the
+ * fence where it lives. A list marker in the prefix is blanked to spaces: a
+ * closer must sit inside the item, and a repeated marker would start a new one.
+ */
+export declare const closingFence: (open: NonNullable<OpenFence>) => string;
+/**
+ * True when `raw` ends inside a fenced block — i.e. the fence is still being
+ * streamed. Only the last block of a live document can be in this state.
+ */
+export declare const hasUnclosedFence: (raw: string) => boolean;

package/dist/utils/fence.js

@@ -0,0 +1,56 @@
+// An opener may sit behind up to 3 spaces of indentation per CommonMark, behind
+// blockquote markers ("> ```" inside a blockquote or an alert), and behind a
+// list marker, because "- ```js" opens a fence in the item.
+const OPENER_LINE = /^([ \t]{0,3}(?:>[ \t]*)*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+)?)(`{3,}|~{3,})(.*)$/;
+// A closer is measured against the opener, not against column 0: it may be
+// indented up to 3 spaces more than the opener was. That is what makes a fence
+// inside a list item close — "10. ```js" opens at column 4, so its "    ```"
+// closer is at 4, which a fixed 0–3 limit rejected.
+const CLOSER_LINE = /^([ \t]*(?:>[ \t]*)*)(`{3,}|~{3,})[ \t]*$/;
+/**
+ * Fence tracking, one line at a time: returns the fence state after `line`.
+ * The completer's block scan and `hasUnclosedFence` both walk with this, so the
+ * "am I inside a fence" answer can never drift between them.
+ */
+export const trackFence = (line, open) => {
+    if (open) {
+        // A closer uses the opener's character, is at least as long, carries no
+        // info string, and is not indented deeper than the opener plus 3 — so a
+        // shorter or deeper fence line inside the block is content.
+        const match = CLOSER_LINE.exec(line);
+        if (!match)
+            return open;
+        const run = match[2];
+        const closes = run[0] === open.char &&
+            run.length >= open.length &&
+            match[1].length <= open.prefix.length + 3;
+        return closes ? null : open;
+    }
+    const match = OPENER_LINE.exec(line);
+    if (!match)
+        return null;
+    const run = match[2];
+    // A backtick fence's info string cannot contain a backtick (marked's own rule),
+    // so such a line opens nothing.
+    if (run[0] === '`' && match[3].includes('`'))
+        return null;
+    return { char: run[0], length: run.length, prefix: match[1] };
+};
+/**
+ * The line that closes `open`, placed at the opener's depth so it closes the
+ * fence where it lives. A list marker in the prefix is blanked to spaces: a
+ * closer must sit inside the item, and a repeated marker would start a new one.
+ */
+export const closingFence = (open) => open.prefix.replace(/[-*+]|\d{1,9}[.)]/g, (marker) => ' '.repeat(marker.length)) +
+    open.char.repeat(open.length);
+/**
+ * True when `raw` ends inside a fenced block — i.e. the fence is still being
+ * streamed. Only the last block of a live document can be in this state.
+ */
+export const hasUnclosedFence = (raw) => {
+    let open = null;
+    for (const line of raw.split('\n')) {
+        open = trackFence(line, open);
+    }
+    return open !== null;
+};

package/dist/utils/parse-incomplete-markdown.d.ts

@@ -1,3 +1,4 @@
+import { type OpenFence } from './fence.js';
 export interface Plugin {
     name: string;
     pattern?: RegExp;
@@ -25,13 +26,16 @@ interface ParseState {
     currentLine: number;
     context: 'normal' | 'list' | 'blockquote' | 'descriptionList';
     blockingContexts: Set<'code' | 'math' | 'center' | 'right'>;
+    /** Delimiter that closes the open math block: '$$' or '\]'. */
+    mathCloser?: '$$' | '\\]';
+    /** The fence still open at the end of the input, if any — what closes it. */
+    openFence?: OpenFence;
     lineContexts?: Array<{
         code: boolean;
         math: boolean;
         center: boolean;
         right: boolean;
     }>;
-    fenceInfo?: string;
     mdxUnclosedTags?: Array<{
         tagName: string;
         lineIndex: number;