svelte-streamdown 3.0.0 → 3.1.0

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

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

@@ -108,12 +108,15 @@ export class IncompleteMarkdownParser {
                     let inMathBlock = false;
                     let inCenterBlock = false;
                     let inRightBlock = false;
+                    let centerOpenLine = -1;
+                    let rightOpenLine = -1;
                     // Track which lines are in which contexts for state management
                     const lineContexts = [];
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];
-                        // Check for block boundaries
-                        if (line.trim().startsWith('```') || line.trim().startsWith('~~~')) {
+                        // Check for block boundaries (fences may be quoted inside blockquotes/alerts: "> ```")
+                        const fenceLine = line.replace(/^[ \t]*(?:>[ \t]*)*/, '');
+                        if (fenceLine.startsWith('```') || fenceLine.startsWith('~~~')) {
                             inCodeBlock = !inCodeBlock;
                         }
                         if (line.trim().startsWith('$$') && !line.trim().includes('$$', 2)) {
@@ -121,12 +124,14 @@ export class IncompleteMarkdownParser {
                         }
                         if (line.trim() === '[center]') {
                             inCenterBlock = true;
+                            centerOpenLine = i;
                         }
                         if (line.trim() === '[/center]') {
                             inCenterBlock = false;
                         }
                         if (line.trim() === '[right]') {
                             inRightBlock = true;
+                            rightOpenLine = i;
                         }
                         if (line.trim() === '[/right]') {
                             inRightBlock = false;
@@ -144,9 +149,11 @@ export class IncompleteMarkdownParser {
                         finalContexts.add('code');
                     if (inMathBlock)
                         finalContexts.add('math');
-                    if (inCenterBlock)
+                    // Only auto-close center/right when content follows the opening tag;
+                    // a bare trailing '[center]'/'[right]' line is left untouched.
+                    if (inCenterBlock && centerOpenLine < lines.length - 1)
                         finalContexts.add('center');
-                    if (inRightBlock)
+                    if (inRightBlock && rightOpenLine < lines.length - 1)
                         finalContexts.add('right');
                     // Return both the text and the updated state
                     return {
@@ -158,20 +165,22 @@ export class IncompleteMarkdownParser {
                     };
                 },
                 postprocess: ({ text, state }) => {
-                    // Complete incomplete blocks at end of input
+                    // Complete incomplete blocks at end of input.
+                    // Close inner blocks (code/math) before alignment wrappers.
+                    let result = text;
                     if (state.blockingContexts.has('code')) {
-                        return text + '\n```';
+                        result += '\n```';
                     }
                     if (state.blockingContexts.has('math')) {
-                        return text + '\n$$';
+                        result += '\n$$';
                     }
                     if (state.blockingContexts.has('center')) {
-                        return text + '\n[/center]';
+                        result += '\n[/center]';
                     }
                     if (state.blockingContexts.has('right')) {
-                        return text + '\n[/right]';
+                        result += '\n[/right]';
                     }
-                    return text;
+                    return result;
                 }
             },
             {
@@ -190,7 +199,13 @@ export class IncompleteMarkdownParser {
                         if (isEndingWithTripleAsterisk) {
                             return line.substring(0, lastTripleAsteriskIndex);
                         }
-                        return line.substring(0, endOfCellOrLine) + '***' + line.substring(endOfCellOrLine);
+                        const before = line.substring(0, endOfCellOrLine);
+                        // Part of the closing '***' may have already arrived (a trailing '*' or
+                        // '**'); only add the missing asterisks so we complete to exactly '***'
+                        // instead of leaving stray asterisks after the text.
+                        const trailing = before.match(/\*+$/)?.[0].length ?? 0;
+                        const missing = trailing >= 1 && trailing <= 2 ? 3 - trailing : 3;
+                        return before + '*'.repeat(missing) + line.substring(endOfCellOrLine);
                     }
                     return line;
                 }
@@ -211,7 +226,12 @@ export class IncompleteMarkdownParser {
                         if (isEndingWithDoubleAsterisk) {
                             return line.substring(0, lastDoubleAsteriskIndex);
                         }
-                        return line.substring(0, endOfCellOrLine) + '**' + line.substring(endOfCellOrLine);
+                        const before = line.substring(0, endOfCellOrLine);
+                        // If the content already ends with a single '*' — the first half of the
+                        // closing '**' arriving mid-stream — only add one more '*' to complete it.
+                        // Otherwise we'd emit '***' and leave a stray '*' after the bold text.
+                        const closing = before.endsWith('*') && !before.endsWith('**') ? '*' : '**';
+                        return before + closing + line.substring(endOfCellOrLine);
                     }
                     return line;
                 }
@@ -232,7 +252,11 @@ export class IncompleteMarkdownParser {
                         if (isEndingWithDoubleUnderscore) {
                             return line.substring(0, lastDoubleUnderscoreIndex);
                         }
-                        return line.substring(0, endOfCellOrLine) + '__' + line.substring(endOfCellOrLine);
+                        const before = line.substring(0, endOfCellOrLine);
+                        // A half-typed closing '__' (a lone trailing '_') only needs one more '_',
+                        // not a full '__' that would leave a stray underscore after the text.
+                        const closing = before.endsWith('_') && !before.endsWith('__') ? '_' : '__';
+                        return before + closing + line.substring(endOfCellOrLine);
                     }
                     return line;
                 }
@@ -253,7 +277,10 @@ export class IncompleteMarkdownParser {
                             if (isEndingWithDoubleTilde) {
                                 return line.substring(0, lastDoubleTildeIndex);
                             }
-                            return line.substring(0, endOfCellOrLine) + '~~' + line.substring(endOfCellOrLine);
+                            const before = line.substring(0, endOfCellOrLine);
+                            // A half-typed closing '~~' (a lone trailing '~') only needs one more '~'.
+                            const closing = before.endsWith('~') && !before.endsWith('~~') ? '~' : '~~';
+                            return before + closing + line.substring(endOfCellOrLine);
                         }
                     }
                     return line;
@@ -435,40 +462,73 @@ export class IncompleteMarkdownParser {
                     return line;
                 }
             },
+            {
+                // Must run before inlineCitation: otherwise a trailing `[^label` gets
+                // closed with a plain `]`, defeating the streamdown:footnote marker.
+                name: 'footnoteRef',
+                pattern: /\[\^[^\]\s,]*/,
+                skipInBlockTypes: ['code', 'math'],
+                handler: ({ line }) => {
+                    if (!line.includes(']')) {
+                        return line.replace(/\[\^[^\]\s,]*/, '[^streamdown:footnote]');
+                    }
+                    return line;
+                }
+            },
             {
                 name: 'inlineCitation',
                 pattern: /\[/,
                 skipInBlockTypes: ['code', 'math'],
                 handler: ({ line }) => {
-                    // Count unescaped opening brackets without matching closing brackets
-                    let unclosedBrackets = 0;
+                    // Lines that already contain link/image "](" syntax belong to the
+                    // linksAndImages plugin: completing or preserving them is its job.
+                    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
-                            const restOfLine = line.substring(i + 1);
-                            const closingIndex = restOfLine.indexOf(']');
-                            if (closingIndex === -1) {
-                                unclosedBrackets++;
+                            if (line.indexOf(']', i + 1) === -1) {
+                                unclosedPositions.push(i);
                             }
                         }
                     }
-                    // If there's an odd number of unclosed brackets, add closing bracket
-                    if (unclosedBrackets % 2 === 1) {
-                        const endOfCellOrLine = findEndOfCellOrLineContaining(line, line.length - 1);
-                        return line.substring(0, endOfCellOrLine) + ']' + line.substring(endOfCellOrLine);
-                    }
-                    return line;
-                }
-            },
-            {
-                name: 'footnoteRef',
-                pattern: /\[\^[^\]\s,]*/,
-                skipInBlockTypes: ['code', 'math'],
-                handler: ({ line }) => {
-                    if (!line.includes(']')) {
-                        return line.replace(/\[\^[^\]\s,]*/, '[^streamdown:footnote]');
+                    // 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) {
+                            continue;
+                        }
+                        if (k === unclosedPositions.length - 1) {
+                            // Last bracket: close at end of cell/line (keeps multi-key citations together)
+                            result =
+                                result.substring(0, endOfCellOrLine) + ']' + result.substring(endOfCellOrLine);
+                        }
+                        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);
+                            }
+                        }
                     }
-                    return line;
+                    return result;
                 }
             },
             {
@@ -638,8 +698,11 @@ export class IncompleteMarkdownParser {
                     const linkMatch = line.match(/(!?\[)([^\]]*?)$/);
                     if (linkMatch && !line.includes('](')) {
                         const [, openBracket, linkTextWithPossibleBoundary] = linkMatch;
-                        // Find the position of the opening bracket
-                        const bracketIndex = line.lastIndexOf(openBracket);
+                        // Position of the matched opening bracket (the regex matches the first
+                        // bracket that stays unclosed through the end of the line). Using the
+                        // match index keeps the replacement aligned with the captured link text;
+                        // `lastIndexOf` could point at a different bracket and duplicate text.
+                        const bracketIndex = linkMatch.index ?? 0;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, bracketIndex);
                         // Extract the clean link text (remove any trailing | or whitespace)
                         const linkText = linkTextWithPossibleBoundary.replace(/[\s|]+$/, '');
@@ -649,24 +712,8 @@ export class IncompleteMarkdownParser {
                         // Replace from bracket to end of cell/line, including boundary if it's |
                         const includeBoundary = endOfCellOrLine < line.length && line[endOfCellOrLine] === '|';
                         const incompleteEnd = includeBoundary ? endOfCellOrLine + 1 : endOfCellOrLine;
-                        const incompletePart = line.substring(bracketIndex, incompleteEnd);
                         const completedPart = openBracket + linkText + '](' + marker + ')' + (includeBoundary ? '|' : '');
-                        return line.replace(incompletePart, completedPart);
-                    }
-                    return line;
-                }
-            },
-            {
-                name: 'alignmentBlocks',
-                pattern: /^(\s*\[(center|right)\])$/,
-                skipInBlockTypes: ['code', 'math'],
-                handler: ({ line, state }) => {
-                    // Check if this is an opening alignment tag without content or closing tag
-                    const alignMatch = line.match(/^(\s*\[(center|right)\])$/);
-                    if (alignMatch) {
-                        const indent = alignMatch[1].length - alignMatch[1].trim().length;
-                        const alignType = alignMatch[2];
-                        return line + '\n' + ' '.repeat(indent) + '[/' + alignType + ']';
+                        return line.substring(0, bracketIndex) + completedPart + line.substring(incompleteEnd);
                     }
                     return line;
                 }
@@ -674,12 +721,19 @@ export class IncompleteMarkdownParser {
             {
                 name: 'mdx',
                 skipInBlockTypes: ['code', 'math', 'center', 'right'],
-                preprocess: ({ text }) => {
+                preprocess: ({ text, state }) => {
                     // Track MDX component states across the entire text
                     const lines = text.split('\n');
                     const openTags = [];
                     let mdxLineStates = [];
                     for (let i = 0; i < lines.length; i++) {
+                        // Lines inside code fences or math blocks are opaque content: MDX-looking
+                        // tags there must not open/close/track components.
+                        const lineCtx = state.lineContexts?.[i];
+                        if (lineCtx?.code || lineCtx?.math) {
+                            mdxLineStates[i] = { inMdx: false, incompletePositions: [] };
+                            continue;
+                        }
                         const line = lines[i];
                         let inMdx = false;
                         let incompletePositions = [];
@@ -691,6 +745,23 @@ export class IncompleteMarkdownParser {
                             if (tagStart === -1 || tagStart >= line.length - 1)
                                 break;
                             const nextChar = line[tagStart + 1];
+                            // Closing tag for a component opened on an earlier line. Handled
+                            // inside the scan so a close that is part of a same-line complete
+                            // pair (consumed below) is never double-counted against the stack.
+                            const closeTagMatch = line.substring(tagStart).match(/^<\/([A-Z][a-zA-Z0-9]*)>/);
+                            if (closeTagMatch) {
+                                const tagName = closeTagMatch[1];
+                                // Pop the innermost same-name open (LIFO) so the auto-appended
+                                // closers keep the right nesting order.
+                                for (let openIndex = openTags.length - 1; openIndex >= 0; openIndex--) {
+                                    if (openTags[openIndex].tagName === tagName) {
+                                        openTags.splice(openIndex, 1);
+                                        break;
+                                    }
+                                }
+                                searchPos = tagStart + closeTagMatch[0].length;
+                                continue;
+                            }
                             // Only match if starts with capital letter (MDX component)
                             if (!/[A-Z]/.test(nextChar)) {
                                 searchPos = tagStart + 1;
@@ -741,16 +812,6 @@ export class IncompleteMarkdownParser {
                             }
                             searchPos = tagStart + 1;
                         }
-                        // Check for closing tags
-                        const closeTagMatches = line.matchAll(/<\/([A-Z][a-zA-Z0-9]*)>/g);
-                        for (const closeMatch of closeTagMatches) {
-                            const tagName = closeMatch[1];
-                            // Find and remove the matching open tag
-                            const openIndex = openTags.findIndex((t) => t.tagName === tagName);
-                            if (openIndex !== -1) {
-                                openTags.splice(openIndex, 1);
-                            }
-                        }
                         mdxLineStates[i] = { inMdx, incompletePositions };
                     }
                     return {

package/dist/utils/url.js

@@ -39,6 +39,12 @@ export const transformUrl = (url, allowedPrefixes, defaultOrigin) => {
     const urlString = parseUrl(url);
     if (urlString &&
         allowedPrefixes.some((prefix) => {
+            // Protocol-only prefixes (e.g. 'https://', 'http://', 'mailto:') allow any
+            // URL using that protocol. They are not valid absolute URLs on their own
+            // (new URL('https://') throws), so we match them with a simple prefix check.
+            if (prefix.endsWith('://') || (prefix.endsWith(':') && !prefix.includes('//'))) {
+                return urlString.href.startsWith(prefix);
+            }
             const parsedPrefix = parseUrl(prefix);
             if (!parsedPrefix) {
                 return false;

package/package.json

@@ -1,6 +1,15 @@
 {
 	"name": "svelte-streamdown",
-	"version": "3.0.0",
+	"version": "3.1.0",
+	"packageManager": "pnpm@10.32.1",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/beynar/svelte-streamdown.git"
+	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -54,6 +63,7 @@
 		"@sveltejs/package": "^2.0.0",
 		"@sveltejs/vite-plugin-svelte": "^6.0.0",
 		"@tailwindcss/vite": "^4.0.0",
+		"@types/node": "^25.9.2",
 		"@vitest/browser": "^3.2.3",
 		"@vitest/ui": "^3.2.4",
 		"playwright": "^1.53.0",