svelte-streamdown 3.0.1 → 3.1.0

package/dist/Streamdown.svelte

@@ -2,7 +2,7 @@
 	import Block from './Block.svelte';
 	import { StreamdownContext, type StreamdownProps } from './context.svelte.js';
 	import { mergeTheme, shadcnTheme } from './theme.js';
-	import { parseBlocks } from './marked/index.js';
+	import { parseBlocks, createParseBlocksCache } from './marked/index.js';
 
 	let {
 		content = '',
@@ -127,11 +127,15 @@
 		},
 		get controls() {
 			const codeControls = controls?.code ?? true;
-			const mermaidControls = controls?.mermaid ?? true;
+			const mermaid = controls?.mermaid;
+			const isMermaidObject = typeof mermaid === 'object' && mermaid !== null;
+			const mermaidControls = isMermaidObject ? (mermaid.enabled ?? true) : (mermaid ?? true);
+			const mermaidMouseWheelZoom = isMermaidObject ? (mermaid.mouseWheelZoom ?? true) : true;
 			const tableControls = controls?.table ?? true;
 			return {
 				code: codeControls,
 				mermaid: mermaidControls,
+				mermaidMouseWheelZoom,
 				table: tableControls
 			};
 		},
@@ -154,7 +158,12 @@
 
 	const id = $props.id();
 
-	const blocks = $derived(isStatic ? content : parseBlocks(content, streamdown.extensions));
+	// Per-instance incremental state: append-only content updates re-lex only
+	// the last couple of blocks instead of the whole document.
+	const blocksCache = createParseBlocksCache();
+	const blocks = $derived(
+		isStatic ? content : parseBlocks(content, streamdown.extensions, blocksCache)
+	);
 </script>
 
 <div bind:this={element} class={className}>

package/dist/context.svelte.d.ts

@@ -11,6 +11,7 @@ export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets
     controls: {
         code: boolean;
         mermaid: boolean;
+        mermaidMouseWheelZoom: boolean;
         table: boolean;
     };
     inlineCitationsMode: 'list' | 'carousel';
@@ -123,7 +124,10 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
     };
     controls?: {
         code?: boolean;
-        mermaid?: boolean;
+        mermaid?: boolean | {
+            enabled?: boolean;
+            mouseWheelZoom?: boolean;
+        };
         table?: boolean;
     };
     renderHtml?: boolean | ((token: Tokens.HTML | Tokens.Tag) => string);

package/dist/marked/index.d.ts

@@ -26,5 +26,19 @@ export type Extension = {
 export type StreamdownToken = Exclude<MarkedToken, Tokens.List | Tokens.ListItem | Tokens.Table> | ListToken | ListItemToken | MathToken | AlertToken | FootnoteToken | SubSupToken | BrToken | HrToken | TableToken | THead | TBody | TFoot | THeadRow | TRow | TH | TD | DescriptionListToken | DescriptionToken | DescriptionDetailToken | DescriptionTermToken | AlignToken | CitationToken | MdxToken;
 export type { TableToken, THead, TBody, TFoot, THeadRow, TRow, TH, TD } from './marked-table.js';
 export declare const lex: (markdown: string, extensions?: Extension[]) => StreamdownToken[];
-export declare const parseBlocks: (markdown: string, extensions?: Extension[]) => string[];
+/**
+ * Opaque incremental state for `parseBlocks`. Create one per Streamdown
+ * instance (or per simulated stream) and pass it on every call: append-only
+ * content updates then re-lex only the last couple of blocks instead of the
+ * whole document. Any non-append update falls back to a full parse.
+ */
+export type ParseBlocksCache = {
+    content: string;
+    /** every block token's raw (including space/footnote tokens) in document order */
+    raws: string[];
+    /** parallel to raws: whether the token is part of the rendered block list */
+    keep: boolean[];
+};
+export declare const createParseBlocksCache: () => ParseBlocksCache;
+export declare const parseBlocks: (markdown: string, extensions?: Extension[], cache?: ParseBlocksCache) => string[];
 export type { MathToken, AlertToken, FootnoteToken, SubSupToken, BrToken, HrToken, AlignToken, CitationToken, MdxToken };

package/dist/marked/index.js

@@ -11,6 +11,34 @@ import { markedDl } from './marked-dl.js';
 import { markedAlign } from './marked-align.js';
 import { markedCitations } from './marked-citations.js';
 import { markedMdx } from './marked-mdx.js';
+// Default plugin sets, in registration order. Hoisted so the options object
+// (and the regexes/closures inside each plugin) is built once, not per chunk.
+// The tokenizers are stateless at creation time — per-document state lives on
+// the Lexer instance (e.g. footnotes maps, reference-link defs), so a fresh
+// Lexer per call keeps documents isolated while the options are shared.
+const DEFAULT_LEX_EXTENSIONS = [
+    markedHr,
+    markedTable,
+    ...markedFootnote(),
+    markedAlert,
+    ...markedMath,
+    markedSub,
+    markedSup,
+    markedList,
+    markedBr,
+    markedDl,
+    markedAlign,
+    markedCitations,
+    markedMdx
+];
+const DEFAULT_BLOCK_EXTENSIONS = [
+    markedHr,
+    ...markedFootnote(),
+    markedDl,
+    markedTable,
+    markedAlign,
+    markedMdx
+];
 const parseExtensions = (...extensions) => {
     const options = {
         gfm: true,
@@ -43,20 +71,105 @@ const parseExtensions = (...extensions) => {
     });
     return options;
 };
+// Options objects are stateless and reusable across Lexer instances; cache them
+// per user-extension array (props are referentially stable across chunks) so the
+// hot path skips rebuilding ~20 tokenizer registrations on every streamed chunk.
+const DEFAULT_LEX_OPTIONS = parseExtensions(...DEFAULT_LEX_EXTENSIONS);
+const DEFAULT_BLOCK_OPTIONS = parseExtensions(...DEFAULT_BLOCK_EXTENSIONS);
+const lexOptionsCache = new WeakMap();
+const blockOptionsCache = new WeakMap();
+const getLexOptions = (extensions) => {
+    if (extensions.length === 0)
+        return DEFAULT_LEX_OPTIONS;
+    let options = lexOptionsCache.get(extensions);
+    if (!options) {
+        options = parseExtensions(...DEFAULT_LEX_EXTENSIONS, ...extensions);
+        lexOptionsCache.set(extensions, options);
+    }
+    return options;
+};
+const getBlockOptions = (extensions) => {
+    if (extensions.length === 0)
+        return DEFAULT_BLOCK_OPTIONS;
+    let options = blockOptionsCache.get(extensions);
+    if (!options) {
+        options = parseExtensions(...DEFAULT_BLOCK_EXTENSIONS, ...extensions.filter(({ level, applyInBlockParsing }) => level === 'block' && applyInBlockParsing));
+        blockOptionsCache.set(extensions, options);
+    }
+    return options;
+};
 export const lex = (markdown, extensions = []) => {
-    return new Lexer(parseExtensions(markedHr, markedTable, ...markedFootnote(), markedAlert, ...markedMath, markedSub, markedSup, markedList, markedBr, markedDl, markedAlign, markedCitations, markedMdx, ...extensions))
+    return new Lexer(getLexOptions(extensions))
         .lex(markdown)
         .filter((token) => token.type !== 'space' && token.type !== 'footnote');
 };
-export const parseBlocks = (markdown, extensions = []) => {
-    const blockLexer = new Lexer(parseExtensions(markedHr, ...markedFootnote(), markedDl, markedTable, markedAlign, markedMdx, ...extensions.filter(({ level, applyInBlockParsing }) => level === 'block' && applyInBlockParsing)));
-    return blockLexer.blockTokens(markdown, []).reduce((acc, block) => {
-        if (block.type === 'space' || block.type === 'footnote') {
-            return acc;
+export const createParseBlocksCache = () => ({
+    content: '',
+    raws: [],
+    keep: []
+});
+// Number of trailing rendered blocks that stay "live" (re-lexed every chunk).
+// 2 covers constructs that merge backward as they stream in — e.g. a paragraph
+// line becoming a table once its delimiter row arrives, or a setext heading.
+const SEAL_SLACK = 2;
+const blockTokensOf = (markdown, extensions) => new Lexer(getBlockOptions(extensions)).blockTokens(markdown, []);
+export const parseBlocks = (markdown, extensions = [], cache) => {
+    if (cache &&
+        cache.content.length > 0 &&
+        markdown.length > cache.content.length &&
+        markdown.startsWith(cache.content)) {
+        // Append-only update: seal everything except the last SEAL_SLACK rendered
+        // blocks and re-lex only the tail. cache.raws concatenates exactly to
+        // cache.content (verified by length below), so summed lengths are offsets.
+        let cut = cache.raws.length;
+        let liveBlocks = 0;
+        while (cut > 0 && liveBlocks < SEAL_SLACK) {
+            cut--;
+            if (cache.keep[cut])
+                liveBlocks++;
+        }
+        let offset = 0;
+        for (let i = 0; i < cut; i++)
+            offset += cache.raws[i].length;
+        const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
+        let tailLength = 0;
+        for (const token of tailTokens)
+            tailLength += token.raw.length;
+        // Contiguity guard: if the lexer normalized the tail (so raws no longer
+        // reconstruct the input), the offsets cannot be trusted — full reparse.
+        if (offset + tailLength === markdown.length) {
+            cache.raws.length = cut;
+            cache.keep.length = cut;
+            for (const token of tailTokens) {
+                cache.raws.push(token.raw);
+                cache.keep.push(token.type !== 'space' && token.type !== 'footnote');
+            }
+            cache.content = markdown;
+            return cache.raws.filter((_, i) => cache.keep[i]);
         }
-        else {
-            acc.push(block.raw);
+    }
+    // Full parse (first call, non-append update, or contiguity fallback).
+    const tokens = blockTokensOf(markdown, extensions);
+    const blocks = [];
+    if (cache) {
+        cache.raws = [];
+        cache.keep = [];
+        let total = 0;
+        for (const token of tokens) {
+            const keep = token.type !== 'space' && token.type !== 'footnote';
+            cache.raws.push(token.raw);
+            cache.keep.push(keep);
+            total += token.raw.length;
+            if (keep)
+                blocks.push(token.raw);
         }
-        return acc;
-    }, []);
+        // Only trust the cache for future appends if raws reconstruct the input.
+        cache.content = total === markdown.length ? markdown : '';
+        return blocks;
+    }
+    for (const token of tokens) {
+        if (token.type !== 'space' && token.type !== 'footnote')
+            blocks.push(token.raw);
+    }
+    return blocks;
 };

package/dist/marked/marked-alert.js

@@ -3,6 +3,14 @@ const variants = ['note', 'tip', 'important', 'warning', 'caution'];
 export function createSyntaxPattern(type) {
     return `^\\s*[\\*_]*\\[!${type.toUpperCase()}\\][\\*_]*\\s*`;
 }
+// Precomputed once per variant instead of recompiling on every blockquote:
+//  - syntax: detects the `[!NOTE]` marker (case-insensitive)
+//  - strip:  removes the marker (global) when building the alert token
+const VARIANT_PATTERNS = variants.map((type) => ({
+    type,
+    syntax: new RegExp(createSyntaxPattern(type), 'i'),
+    strip: new RegExp(`[\\*_]*\\[!${type.toUpperCase()}\\][\\*_]*`, 'g')
+}));
 const defaultLexer = new Lexer({ gfm: true });
 const defaultTokenizer = defaultLexer.options.tokenizer;
 export const markedAlert = {
@@ -18,8 +26,8 @@ export const markedAlert = {
     }
 };
 export function processAlertToken(token, tokenizer) {
-    const matchedVariant = variants.find((type) => new RegExp(createSyntaxPattern(type), 'i').test(('text' in token && token.text) || ''));
-    if (!matchedVariant) {
+    const matched = VARIANT_PATTERNS.find((v) => v.syntax.test(('text' in token && token.text) || ''));
+    if (!matched) {
         Object.assign(token, {
             tokens: token.tokens
                 .map((token) => {
@@ -29,7 +37,8 @@ export function processAlertToken(token, tokenizer) {
         });
         return;
     }
-    const alertPattern = new RegExp(`[\\*_]*\\[!${matchedVariant.toUpperCase()}\\][\\*_]*`, 'g');
+    const matchedVariant = matched.type;
+    const alertPattern = matched.strip;
     const tokens = token.tokens
         .map((token) => {
         let cleanedRaw = token.raw;

package/dist/marked/marked-align.js

@@ -2,11 +2,15 @@ export const markedAlign = {
     name: 'align',
     level: 'block',
     tokenizer(src) {
-        // Check if the source starts with [center] or [right] blocks
-        const centerMatch = src.match(/^\[center\]\n([\s\S]*?)\n\[\/center\]/);
-        const rightMatch = src.match(/^\[right\]\n([\s\S]*?)\n\[\/right\]/);
+        // Check if the source starts with [center] or [right] blocks.
+        // A block ends at its explicit closing tag, or right before the opening
+        // tag of the next alignment block (blocks don't nest — they become
+        // siblings). The content group is optional so empty blocks
+        // ([center]\n[/center]) tokenize too.
+        const centerMatch = src.match(/^\[center\]\n(?:([\s\S]*?)\n)?(?:\[\/center\]|(?=\[(?:center|right)\]\n))/);
+        const rightMatch = src.match(/^\[right\]\n(?:([\s\S]*?)\n)?(?:\[\/right\]|(?=\[(?:center|right)\]\n))/);
         if (centerMatch) {
-            const text = centerMatch[1];
+            const text = centerMatch[1] ?? '';
             const raw = centerMatch[0];
             // Tokenize the content inside the alignment block
             const tokens = this.lexer.blockTokens(text, []);
@@ -19,7 +23,7 @@ export const markedAlign = {
             };
         }
         if (rightMatch) {
-            const text = rightMatch[1];
+            const text = rightMatch[1] ?? '';
             const raw = rightMatch[0];
             // Tokenize the content inside the alignment block
             const tokens = this.lexer.blockTokens(text, []);

package/dist/marked/marked-citations.js

@@ -2,12 +2,13 @@ export const markedCitations = {
     name: 'citations',
     level: 'inline',
     start(src) {
-        return src.indexOf('[') === -1 ? -1 : 0;
+        const i = src.indexOf('[');
+        return i === -1 ? -1 : i;
     },
     tokenizer(src) {
         // Match inline citations like [1], [ref], [1] [2], [ref] [ref2], etc.
         // Requires non-empty bracket contents and spaces between adjacent citation brackets
-        const match = src.match(/^\[[^\]]+\](?:\s+\[[^\]]+\])*/);
+        const match = src.match(/^\[[^\][]+\](?:\s+\[[^\][]+\])*/);
         if (match) {
             // Early exit: if first closing bracket is immediately followed by '[', it's likely link-style syntax
             const firstClosingBracketIndex = src.indexOf(']');
@@ -20,7 +21,7 @@ export const markedCitations = {
                 return undefined;
             }
             // Extract all citation keys (anything inside brackets)
-            const citations = match[0].match(/\[([^\]]+)\]/g);
+            const citations = match[0].match(/\[([^\][]+)\]/g);
             if (citations) {
                 // Filter out task list syntax ([ ], [x], [X]) after trimming
                 const validCitations = citations.filter((citation) => {

package/dist/marked/marked-dl.js

@@ -1,16 +1,21 @@
+// Hoisted to module scope: these are stateless (no `g` flag) and were previously
+// recompiled on every tokenizer call (DL_RULE) and every line of a growing list (DL_LINE_RULE).
+// The detail group must accept colons (`Time: 10:30`) and mirror DL_RULE exactly:
+// any line the block rule consumes must also match here, or it silently vanishes.
+const DL_RULE = /^(?:[ \t]*:[^:\n]+:[ \t]?[^\n]*(?:\n|$))+/;
+const DL_LINE_RULE = /^\s*:([^:\n]+):([^\n]*)(?:\n|$)/;
 export const markedDl = {
     name: 'descriptionList',
     level: 'block', // Is this a block-level or inline-level tokenizer?
     tokenizer(src) {
-        const rule = /^(?:[ \t]*:[^:\n]+:[ \t]?[^\n]*(?:\n|$))+/;
-        const match = rule.exec(src);
+        const match = DL_RULE.exec(src);
         if (match) {
             const text = match[0].trim();
             const tokens = [];
             // Parse each line as a description
             const lines = text.split('\n');
             for (const line of lines) {
-                const lineMatch = /^\s*:([^:\n]+):([^:\n]*)(?:\n|$)/.exec(line);
+                const lineMatch = DL_LINE_RULE.exec(line);
                 if (lineMatch) {
                     const term = lineMatch[1].trim();
                     const detail = lineMatch[2].trim();

package/dist/marked/marked-hr.js

@@ -3,9 +3,10 @@ export const markedHr = {
     level: 'block',
     tokenizer(src) {
         // Match horizontal rules according to CommonMark spec:
-        // 3 or more matching -, _, or * characters, with optional spaces between
-        // Must be at start of string and match entire line
-        const match = src.match(/^[ \t]*(-[ \t]*-[ \t]*-+|_[ \t]*_[ \t]*_+|\*[ \t]*\*[ \t]*\*+)[ \t]*(?:\n|$)/);
+        // 3 or more matching -, _, or * characters, each optionally followed by
+        // spaces/tabs ("- - - -" is a thematic break, not a list). Must be at
+        // start of string and match the entire line.
+        const match = src.match(/^[ \t]*(?:(?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n|$)/);
         if (match) {
             const raw = match[0].replace(/\n$/, ''); // Remove trailing newline from raw
             return {

package/dist/marked/marked-list.js

@@ -26,6 +26,38 @@ export const romanLower = '(?:c|xc|l?x{0,3}(?:ix|iv|v?i{0,3}))';
 // Fixed regex pattern - carefully balanced parentheses
 export const bulletPattern = `(?:[*+-]|(?:\\d{1,9}|[a-zA-Z]|${romanUpper}|${romanLower})[.)])`;
 export const rule = `^( {0,3}${bulletPattern})([ \\t][^\\n]*|[ \\t])?(?:\\n|$)`;
+// --- Precompiled regexes ---------------------------------------------------
+// These were previously rebuilt on every tokenizer call and, for the boundary
+// set, on every item iteration. They are stateless (no `g` flag) so they are
+// safe to share. This is the bulk of the per-chunk list cost.
+const RULE_RE = new RegExp(rule);
+const ROMAN_UPPER_RE = new RegExp(`^${romanUpper}[.)]$`);
+const ROMAN_LOWER_RE = new RegExp(`^${romanLower}[.)]$`);
+const LOWER_ALPHA_RE = /^[a-z][.)]$/;
+const UPPER_ALPHA_RE = /^[A-Z][.)]$/;
+// The per-item boundary regexes vary only by the indent clamp (0..3); build the
+// four variants once at module load and index into them.
+function buildBoundaryRegexes(maxIndent) {
+    return {
+        nextBullet: new RegExp(`^ {0,${maxIndent}}(?:[*+-]|(?:\\d{1,9}|[a-zA-Z]|${romanUpper}|${romanLower})[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),
+        hr: new RegExp(`^ {0,${maxIndent}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+        fences: new RegExp(`^ {0,${maxIndent}}(?:\`\`\`|~~~)`),
+        heading: new RegExp(`^ {0,${maxIndent}}#`),
+        html: new RegExp(`^ {0,${maxIndent}}<[a-z].*>`, 'i')
+    };
+}
+const LIST_BOUNDARY_TABLE = [0, 1, 2, 3].map(buildBoundaryRegexes);
+// itemRegex depends only on `bull`, which has a small finite set of shapes;
+// cache the compiled instances instead of recompiling per tokenizer call.
+const itemRegexCache = new Map();
+function getItemRegex(bull) {
+    let re = itemRegexCache.get(bull);
+    if (!re) {
+        re = new RegExp(`^( {0,3}${bull})([\t ][^\\n]*|[\t ])?(?:\\n|$)`);
+        itemRegexCache.set(bull, re);
+    }
+    return re;
+}
 function finalizeList(list, lexer) {
     if (list.tokens.length === 0)
         return;
@@ -38,11 +70,21 @@ function finalizeList(list, lexer) {
     for (const item of list.tokens) {
         lexer.state.top = false;
         item.tokens = lexer.blockTokens(item.text, []);
+        // A blank line inside a single item also makes the list loose
+        if (!list.loose) {
+            const spaceTokens = item.tokens.filter((token) => token.type === 'space');
+            if (spaceTokens.length > 0 && spaceTokens.some((token) => /\n.*\n/.test(token.raw))) {
+                list.loose = true;
+            }
+        }
     }
-    // Mark list as loose if needed
+    // Mark list as loose if needed and re-tokenize items as block content so
+    // their text becomes paragraph tokens instead of inline text
     if (list.loose) {
         for (const item of list.tokens) {
             item.loose = true;
+            lexer.state.top = true;
+            item.tokens = lexer.blockTokens(item.text, []);
         }
     }
 }
@@ -53,7 +95,7 @@ export const markedList = {
     name: 'list',
     level: 'block',
     tokenizer(src) {
-        let cap = new RegExp(rule).exec(src);
+        let cap = RULE_RE.exec(src);
         if (!cap)
             return undefined;
         const bullet = cap[1].trim();
@@ -63,19 +105,19 @@ export const markedList = {
         let expectedValue = null;
         // Detect list type (Roman, alphabetic, numeric)
         if (isOrdered) {
-            if (bullet.match(new RegExp(`^${romanUpper}[.)]$`))) {
+            if (ROMAN_UPPER_RE.test(bullet)) {
                 type = 'upper-roman';
                 bull = `${romanUpper}\\${bullet.slice(-1)}`;
             }
-            else if (bullet.match(new RegExp(`^${romanLower}[.)]$`))) {
+            else if (ROMAN_LOWER_RE.test(bullet)) {
                 type = 'lower-roman';
                 bull = `${romanLower}\\${bullet.slice(-1)}`;
             }
-            else if (bullet.match(/^[a-z][.)]$/)) {
+            else if (LOWER_ALPHA_RE.test(bullet)) {
                 type = 'lower-alpha';
                 bull = `[a-z]\\${bullet.slice(-1)}`;
             }
-            else if (bullet.match(/^[A-Z][.)]$/)) {
+            else if (UPPER_ALPHA_RE.test(bullet)) {
                 type = 'upper-alpha';
                 bull = `[A-Z]\\${bullet.slice(-1)}`;
             }
@@ -85,7 +127,6 @@ export const markedList = {
             }
         }
         else {
-            bull = this.lexer.options.pedantic ? bullet : '[*+-]';
             bull = this.lexer.options.pedantic ? escapeForRegex(bullet) : '[*+-]';
         }
         const list = {
@@ -99,7 +140,7 @@ export const markedList = {
         };
         // Get next list item
         // Updated regex to properly handle empty list items (space after bullet, then newline)
-        const itemRegex = new RegExp(`^( {0,3}${bull})([\t ][^\\n]*|[\t ])?(?:\\n|$)`);
+        const itemRegex = getItemRegex(bull);
         let endsWithBlankLine = false;
         // Check if current bullet point can start a new List Item
         while (src) {
@@ -137,20 +178,16 @@ export const markedList = {
                 endEarly = true;
             }
             if (!endEarly) {
-                const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|(?:\\d{1,9}|[a-zA-Z]|${romanUpper}|${romanLower})[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`);
-                const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
-                const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
-                const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
-                const htmlBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}<[a-z].*>`, 'i');
+                const { nextBullet, hr, fences, heading, html } = LIST_BOUNDARY_TABLE[Math.min(3, indent - 1)];
                 // Check if following lines should be included in List Item
                 while (src) {
                     const rawLine = src.split('\n', 1)[0];
                     const nextLineWithoutTabs = rawLine.replace(/\t/g, '    ');
-                    if (fencesBeginRegex.test(nextLineWithoutTabs) ||
-                        headingBeginRegex.test(nextLineWithoutTabs) ||
-                        htmlBeginRegex.test(nextLineWithoutTabs) ||
-                        nextBulletRegex.test(nextLineWithoutTabs) ||
-                        hrRegex.test(nextLineWithoutTabs))
+                    if (fences.test(nextLineWithoutTabs) ||
+                        heading.test(nextLineWithoutTabs) ||
+                        html.test(nextLineWithoutTabs) ||
+                        nextBullet.test(nextLineWithoutTabs) ||
+                        hr.test(nextLineWithoutTabs))
                         break;
                     if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLineWithoutTabs.trim()) {
                         itemContents += '\n' + nextLineWithoutTabs.slice(indent);

package/dist/marked/marked-math.js

@@ -48,21 +48,19 @@ export const markedMath = [
                 const currentIndex = index + dollarIndex;
                 const possibleMath = src.substring(currentIndex);
                 // Check if this could be math (not currency)
-                if (possibleMath.match(inlineRule)) {
-                    const match = possibleMath.match(inlineRule);
-                    if (match) {
-                        const content = match[2];
-                        const dollarCount = match[1]; // '$' or '$$'
-                        // Only apply currency detection to single dollars
-                        // Double dollars ($$) indicate explicit math intent
-                        if (dollarCount === '$' && isCurrencyPattern(content, src, currentIndex)) {
-                            // This looks like currency with single dollars, skip it
-                            index += dollarIndex + 1;
-                            searchSrc = src.substring(index);
-                            continue;
-                        }
-                        return currentIndex;
+                const match = possibleMath.match(inlineRule);
+                if (match) {
+                    const content = match[2];
+                    const dollarCount = match[1]; // '$' or '$$'
+                    // Only apply currency detection to single dollars
+                    // Double dollars ($$) indicate explicit math intent
+                    if (dollarCount === '$' && isCurrencyPattern(content, src, currentIndex)) {
+                        // This looks like currency with single dollars, skip it
+                        index += dollarIndex + 1;
+                        searchSrc = src.substring(index);
+                        continue;
                     }
+                    return currentIndex;
                 }
                 index += dollarIndex + 1;
                 searchSrc = src.substring(index);

package/dist/marked/marked-table.js

@@ -90,12 +90,9 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
     const processedCells = [];
     // Track colspan cells that need rowspan
     const colspanCells = new Map();
-    // First pass: Process each cell's colspan and merge consecutive empty cells
+    // First pass: Process each cell's colspan
     let cellIndex = 0;
-    const mergedIndices = new Set();
     for (i = 0; i < cells.length; i++) {
-        if (mergedIndices.has(i))
-            continue;
         trimmedCell = cells[i];
         let colspan = 1;
         // Check for colspan marker from consecutive pipes
@@ -104,24 +101,6 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
             trimmedCell = parts[0];
             colspan = parseInt(parts[1], 10);
         }
-        else if (!trimmedCell.trim()) {
-            // Fallback: merge empty run into previous cell (backward compatibility)
-            let run = 1, k = i + 1;
-            while (k < cells.length && !cells[k].trim()) {
-                run++;
-                mergedIndices.add(k++);
-            }
-            if (processedCells.length) {
-                const target = processedCells[processedCells.length - 1];
-                const allowed = maxColspan != null ? Math.min(run, Math.max(0, maxColspan - target.colspan)) : run;
-                target.colspan += allowed;
-                numCols += allowed;
-                continue;
-            }
-            else {
-                colspan = maxColspan != null ? Math.min(run, maxColspan) : run;
-            }
-        }
         if (maxColspan !== null && colspan > maxColspan)
             colspan = maxColspan;
         processedCells[cellIndex] = {
@@ -141,8 +120,11 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
         // Check if it's a rowspan indicator (single ^ at end) vs superscript (^text^)
         const isRowspanIndicator = cellText.slice(-1) === '^' && !cellText.match(/\^[^^\n\r]+\^$/); // Not a superscript pattern ^text^
         if (isRowspanIndicator && prevRow.length > 0) {
-            // Clean the ^ indicator from the cell text
+            // Clean the ^ indicator from the cell text. A cell that is nothing but
+            // carets (the usual `^^` continuation marker) carries no content.
             cell.text = cellText.slice(0, -1).trim();
+            if (/^\^*$/.test(cell.text))
+                cell.text = '';
             cellText = cell.text;
             let targetFound = false;
             const startPosition = cell.position || 0;
@@ -161,8 +143,10 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
                         // If the cell spans exactly match, simple case
                         if (cell.colspan === prevCell.colspan && cell.position === prevCell.position) {
                             cell.rowSpanTarget = prevCell.rowSpanTarget ?? prevCell;
-                            // Only append text if it's different from the target cell
-                            const textToAppend = cell.text.slice(0, -1).trim();
+                            // Only append text if it's different from the target cell.
+                            // cell.text was already cleaned of its ^ indicator above —
+                            // slicing again here used to drop the last real character.
+                            const textToAppend = cell.text.trim();
                             const targetText = cell.rowSpanTarget.text.trim();
                             // Don't append if the text is the same or already contained (common case for rowspan indicators)
                             if (textToAppend &&
@@ -188,8 +172,9 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
                     else {
                         // Standard case of single column cell with rowspan
                         cell.rowSpanTarget = prevCell.rowSpanTarget ?? prevCell;
-                        // Only append text if it's different from the target cell
-                        const textToAppend = cell.text.slice(0, -1).trim();
+                        // Only append text if it's different from the target cell.
+                        // cell.text was already cleaned of its ^ indicator above.
+                        const textToAppend = cell.text.trim();
                         const targetText = cell.rowSpanTarget.text.trim();
                         // Don't append if the text is the same or already contained (common case for rowspan indicators)
                         if (textToAppend && textToAppend !== targetText && !targetText.includes(textToAppend)) {
@@ -202,13 +187,8 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
                     }
                 }
             }
-            // If no target was found but it's a rowspan cell, clean the ^ indicator
-            if (!targetFound && cell.rowspan > 0) {
-                // Only clean if it was actually a rowspan indicator, not superscript
-                if (isRowspanIndicator) {
-                    cell.text = cell.text.slice(0, -1);
-                }
-            }
+            // No target found: cell.text was already cleaned of its ^ indicator
+            // above, so the cell simply renders as a normal cell.
         }
     }
     // Process any complex colspan+rowspan combinations we tracked