svelte-streamdown 2.3.1 → 2.3.3

package/dist/marked/marked-list.js

@@ -49,190 +49,184 @@ function finalizeList(list, lexer) {
 function escapeForRegex(s) {
     return s.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
 }
-export function markedList() {
-    return {
-        extensions: [
-            {
-                name: 'list',
-                level: 'block',
-                tokenizer(src) {
-                    let cap = new RegExp(rule).exec(src);
-                    if (!cap)
-                        return null;
-                    const bullet = cap[1].trim();
-                    const isOrdered = bullet !== '*' && bullet !== '-' && bullet !== '+';
-                    let bull;
-                    let type = '';
-                    let expectedValue = null;
-                    // Detect list type (Roman, alphabetic, numeric)
-                    if (isOrdered) {
-                        if (bullet.match(new RegExp(`^${romanUpper}[.)]$`))) {
-                            type = 'upper-roman';
-                            bull = `${romanUpper}\\${bullet.slice(-1)}`;
-                        }
-                        else if (bullet.match(new RegExp(`^${romanLower}[.)]$`))) {
-                            type = 'lower-roman';
-                            bull = `${romanLower}\\${bullet.slice(-1)}`;
-                        }
-                        else if (bullet.match(/^[a-z][.)]$/)) {
-                            type = 'lower-alpha';
-                            bull = `[a-z]\\${bullet.slice(-1)}`;
-                        }
-                        else if (bullet.match(/^[A-Z][.)]$/)) {
-                            type = 'upper-alpha';
-                            bull = `[A-Z]\\${bullet.slice(-1)}`;
-                        }
-                        else {
-                            type = 'decimal';
-                            bull = `\\d{1,9}\\${bullet.slice(-1)}`;
-                        }
+export const markedList = {
+    name: 'list',
+    level: 'block',
+    tokenizer(src) {
+        let cap = new RegExp(rule).exec(src);
+        if (!cap)
+            return undefined;
+        const bullet = cap[1].trim();
+        const isOrdered = bullet !== '*' && bullet !== '-' && bullet !== '+';
+        let bull;
+        let type = '';
+        let expectedValue = null;
+        // Detect list type (Roman, alphabetic, numeric)
+        if (isOrdered) {
+            if (bullet.match(new RegExp(`^${romanUpper}[.)]$`))) {
+                type = 'upper-roman';
+                bull = `${romanUpper}\\${bullet.slice(-1)}`;
+            }
+            else if (bullet.match(new RegExp(`^${romanLower}[.)]$`))) {
+                type = 'lower-roman';
+                bull = `${romanLower}\\${bullet.slice(-1)}`;
+            }
+            else if (bullet.match(/^[a-z][.)]$/)) {
+                type = 'lower-alpha';
+                bull = `[a-z]\\${bullet.slice(-1)}`;
+            }
+            else if (bullet.match(/^[A-Z][.)]$/)) {
+                type = 'upper-alpha';
+                bull = `[A-Z]\\${bullet.slice(-1)}`;
+            }
+            else {
+                type = 'decimal';
+                bull = `\\d{1,9}\\${bullet.slice(-1)}`;
+            }
+        }
+        else {
+            bull = this.lexer.options.pedantic ? bullet : '[*+-]';
+            bull = this.lexer.options.pedantic ? escapeForRegex(bullet) : '[*+-]';
+        }
+        const list = {
+            type: 'list',
+            raw: '',
+            ordered: isOrdered,
+            listType: isOrdered ? type : null,
+            loose: false,
+            start: undefined, // Will be set when first item is processed
+            tokens: []
+        };
+        // 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|$)`);
+        let endsWithBlankLine = false;
+        // Check if current bullet point can start a new List Item
+        while (src) {
+            let raw = '';
+            let itemContents = '';
+            let endEarly = false;
+            if (!(cap = itemRegex.exec(src)))
+                break;
+            raw = cap[0];
+            const bullet = cap[1].trim();
+            src = src.substring(raw.length);
+            const line = cap[2]
+                ? cap[2].split('\n', 1)[0].replace(/^\t+/, (t) => ' '.repeat(4 * t.length))
+                : '';
+            const nextLine = src.split('\n', 1)[0];
+            const blankLine = !line.trim();
+            let indent = 0;
+            if (this.lexer.options.pedantic) {
+                indent = 2;
+                itemContents = line.trimStart();
+            }
+            else if (blankLine) {
+                indent = cap[1].length + 1;
+            }
+            else {
+                indent = cap[2].search(/[^ ]/); // Find first non-space char
+                indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
+                itemContents = line.slice(indent);
+                indent += cap[1].length;
+            }
+            if (blankLine && /^[ \t]*$/.test(nextLine)) {
+                // Items begin with at most one blank line
+                raw += nextLine + '\n';
+                src = src.substring(nextLine.length + 1);
+                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');
+                // 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))
+                        break;
+                    if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLineWithoutTabs.trim()) {
+                        itemContents += '\n' + nextLineWithoutTabs.slice(indent);
                     }
                     else {
-                        bull = this.lexer.options.pedantic ? bullet : '[*+-]';
-                        bull = this.lexer.options.pedantic ? escapeForRegex(bullet) : '[*+-]';
+                        itemContents += '\n' + nextLineWithoutTabs;
                     }
-                    const list = {
-                        type: 'list',
-                        raw: '',
-                        ordered: isOrdered,
-                        listType: isOrdered ? type : null,
-                        loose: false,
-                        start: undefined, // Will be set when first item is processed
-                        tokens: []
-                    };
-                    // 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|$)`);
-                    let endsWithBlankLine = false;
-                    // Check if current bullet point can start a new List Item
-                    while (src) {
-                        let raw = '';
-                        let itemContents = '';
-                        let endEarly = false;
-                        if (!(cap = itemRegex.exec(src)))
-                            break;
-                        raw = cap[0];
-                        const bullet = cap[1].trim();
-                        src = src.substring(raw.length);
-                        const line = cap[2]
-                            ? cap[2].split('\n', 1)[0].replace(/^\t+/, (t) => ' '.repeat(3 * t.length))
-                            : '';
-                        const nextLine = src.split('\n', 1)[0];
-                        const blankLine = !line.trim();
-                        let indent = 0;
-                        if (this.lexer.options.pedantic) {
-                            indent = 2;
-                            itemContents = line.trimStart();
-                        }
-                        else if (blankLine) {
-                            indent = cap[1].length + 1;
-                        }
-                        else {
-                            indent = cap[2].search(/[^ ]/); // Find first non-space char
-                            indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
-                            itemContents = line.slice(indent);
-                            indent += cap[1].length;
-                        }
-                        if (blankLine && /^[ \t]*$/.test(nextLine)) {
-                            // Items begin with at most one blank line
-                            raw += nextLine + '\n';
-                            src = src.substring(nextLine.length + 1);
-                            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');
-                            // 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))
-                                    break;
-                                if (nextLineWithoutTabs.search(/[^ ]/) >= indent || !nextLineWithoutTabs.trim()) {
-                                    itemContents += '\n' + nextLineWithoutTabs.slice(indent);
-                                }
-                                else {
-                                    itemContents += '\n' + nextLineWithoutTabs;
-                                }
-                                raw += rawLine + '\n';
-                                src = src.substring(rawLine.length + 1);
-                            }
-                        }
-                        if (!list.loose) {
-                            // If the previous item ended with a blank line, the list is loose
-                            if (endsWithBlankLine) {
-                                list.loose = true;
-                            }
-                            else if (/\n[ \t]*\n[ \t]*$/.test(raw)) {
-                                endsWithBlankLine = true;
-                            }
-                        }
-                        let isTask = null;
-                        let isChecked = false;
-                        // Check for task list items
-                        if (this.lexer.options.gfm) {
-                            isTask = /^\[[ xX]] /.exec(itemContents);
-                            if (isTask) {
-                                isChecked = isTask[0] !== '[ ] ';
-                                itemContents = itemContents.replace(/^\[[ xX]] +/, '');
-                            }
-                        }
-                        let value = null;
-                        if (!isOrdered) {
-                            // Do nothing for unordered lists
-                        }
-                        else if (type === 'decimal') {
-                            value = parseInt(bullet.slice(0, -1), 10);
-                        }
-                        else if (type === 'lower-alpha' || type === 'upper-alpha') {
-                            value = letterToInt(bullet.slice(0, -1));
-                        }
-                        else if (type === 'lower-roman' || type === 'upper-roman') {
-                            value = romanToInt(bullet.slice(0, -1));
-                        }
-                        // Handle expectedValue initialization and validation
-                        let skipped = false;
-                        if (isOrdered) {
-                            if (expectedValue === null) {
-                                // First item: set expectedValue to this item's value (or 1 if parsing failed)
-                                expectedValue = value ?? 1;
-                                // Set the start property for ordered lists
-                                list.start = expectedValue;
-                            }
-                            else {
-                                // Subsequent items: check if value matches expected
-                                skipped = value !== null && value !== expectedValue;
-                                // Increment expectedValue for next item
-                                expectedValue += 1;
-                            }
-                        }
-                        list.tokens.push({
-                            type: 'list_item',
-                            raw,
-                            task: !!isTask,
-                            checked: isChecked,
-                            loose: false,
-                            text: itemContents,
-                            value,
-                            skipped,
-                            tokens: []
-                        });
-                        list.raw += raw;
-                    }
-                    if (list.tokens.length === 0)
-                        return null;
-                    // Finalize the list
-                    finalizeList(list, this.lexer);
-                    return list;
+                    raw += rawLine + '\n';
+                    src = src.substring(rawLine.length + 1);
                 }
             }
-        ]
-    };
-}
+            if (!list.loose) {
+                // If the previous item ended with a blank line, the list is loose
+                if (endsWithBlankLine) {
+                    list.loose = true;
+                }
+                else if (/\n[ \t]*\n[ \t]*$/.test(raw)) {
+                    endsWithBlankLine = true;
+                }
+            }
+            let isTask = null;
+            let isChecked = false;
+            // Check for task list items
+            if (this.lexer.options.gfm) {
+                isTask = /^\[[ xX]] /.exec(itemContents);
+                if (isTask) {
+                    isChecked = isTask[0] !== '[ ] ';
+                    itemContents = itemContents.replace(/^\[[ xX]] +/, '');
+                }
+            }
+            let value = null;
+            if (!isOrdered) {
+                // Do nothing for unordered lists
+            }
+            else if (type === 'decimal') {
+                value = parseInt(bullet.slice(0, -1), 10);
+            }
+            else if (type === 'lower-alpha' || type === 'upper-alpha') {
+                value = letterToInt(bullet.slice(0, -1));
+            }
+            else if (type === 'lower-roman' || type === 'upper-roman') {
+                value = romanToInt(bullet.slice(0, -1));
+            }
+            // Handle expectedValue initialization and validation
+            let skipped = false;
+            if (isOrdered) {
+                if (expectedValue === null) {
+                    // First item: set expectedValue to this item's value (or 1 if parsing failed)
+                    expectedValue = value ?? 1;
+                    // Set the start property for ordered lists
+                    list.start = expectedValue;
+                }
+                else {
+                    // Subsequent items: check if value matches expected
+                    skipped = value !== null && value !== expectedValue;
+                    // Increment expectedValue for next item
+                    expectedValue += 1;
+                }
+            }
+            list.tokens.push({
+                type: 'list_item',
+                raw,
+                task: !!isTask,
+                checked: isChecked,
+                loose: false,
+                text: itemContents,
+                value,
+                skipped,
+                tokens: []
+            });
+            list.raw += raw;
+        }
+        if (list.tokens.length === 0)
+            return undefined;
+        // Finalize the list
+        finalizeList(list, this.lexer);
+        return list;
+    }
+};

package/dist/marked/marked-math.d.ts

@@ -1,12 +1,5 @@
-import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
-export declare function markedMath(): {
-    extensions: Array<{
-        name: string;
-        level: 'block' | 'inline';
-        tokenizer: TokenizerExtensionFunction;
-        start?: TokenizerStartFunction;
-    }>;
-};
+import type { Extension } from './index.js';
+export declare const markedMath: Extension[];
 export type MathToken = {
     type: 'math';
     raw: string;

package/dist/marked/marked-math.js

@@ -15,86 +15,82 @@ const currencyPatterns = {
     // Common currency words nearby (check surrounding context)
     currencyContext: /(?:price|cost|dollar|euro|pound|yen|currency|pay|buy|sell|expensive|cheap)/i
 };
-export function markedMath() {
-    return {
-        extensions: [
-            {
-                name: 'math',
-                level: 'block',
-                tokenizer(src) {
-                    const match = src.match(blockRule);
-                    if (match) {
-                        // match[2] is multiline format, match[3] is single-line format
-                        const content = (match[2] || match[3]).trim();
-                        return {
-                            type: 'math',
-                            isInline: false,
-                            displayMode: true,
-                            raw: match[0],
-                            text: content
-                        };
-                    }
+export const markedMath = [
+    {
+        name: 'math',
+        level: 'block',
+        tokenizer(src) {
+            const match = src.match(blockRule);
+            if (match) {
+                // match[2] is multiline format, match[3] is single-line format
+                const content = (match[2] || match[3]).trim();
+                return {
+                    type: 'math',
+                    isInline: false,
+                    displayMode: true,
+                    raw: match[0],
+                    text: content
+                };
+            }
+        }
+    },
+    {
+        name: 'math',
+        level: 'inline',
+        start(src) {
+            let index = 0;
+            let searchSrc = src;
+            while (searchSrc) {
+                const dollarIndex = searchSrc.indexOf('$');
+                if (dollarIndex === -1) {
+                    return;
                 }
-            },
-            {
-                name: 'math',
-                level: 'inline',
-                start(src) {
-                    let index = 0;
-                    let searchSrc = src;
-                    while (searchSrc) {
-                        const dollarIndex = searchSrc.indexOf('$');
-                        if (dollarIndex === -1) {
-                            return;
-                        }
-                        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;
-                            }
-                        }
-                        index += dollarIndex + 1;
-                        searchSrc = src.substring(index);
-                    }
-                },
-                tokenizer(src) {
-                    const match = src.match(inlineRule);
+                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 '$$'
-                        const isDisplayMode = dollarCount === '$$';
                         // Only apply currency detection to single dollars
                         // Double dollars ($$) indicate explicit math intent
-                        if (dollarCount === '$' && isCurrencyPattern(content, src, 0)) {
+                        if (dollarCount === '$' && isCurrencyPattern(content, src, currentIndex)) {
                             // This looks like currency with single dollars, skip it
-                            return;
+                            index += dollarIndex + 1;
+                            searchSrc = src.substring(index);
+                            continue;
                         }
-                        return {
-                            type: 'math',
-                            isInline: true, // Inline tokenizer always produces inline math
-                            displayMode: isDisplayMode, // $$ = display mode styling, $ = inline styling
-                            raw: match[0],
-                            text: content.trim()
-                        };
+                        return currentIndex;
                     }
                 }
+                index += dollarIndex + 1;
+                searchSrc = src.substring(index);
             }
-        ]
-    };
-}
+        },
+        tokenizer(src) {
+            const match = src.match(inlineRule);
+            if (match) {
+                const content = match[2];
+                const dollarCount = match[1]; // '$' or '$$'
+                const isDisplayMode = dollarCount === '$$';
+                // Only apply currency detection to single dollars
+                // Double dollars ($$) indicate explicit math intent
+                if (dollarCount === '$' && isCurrencyPattern(content, src, 0)) {
+                    // This looks like currency with single dollars, skip it
+                    return;
+                }
+                return {
+                    type: 'math',
+                    isInline: true, // Inline tokenizer always produces inline math
+                    displayMode: isDisplayMode, // $$ = display mode styling, $ = inline styling
+                    raw: match[0],
+                    text: content.trim()
+                };
+            }
+        }
+    }
+];
 // Helper function to detect currency patterns
 function isCurrencyPattern(content, fullSrc, dollarIndex) {
     const trimmedContent = content.trim();

package/dist/marked/marked-subsup.d.ts

@@ -1,12 +1,6 @@
-import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
-export declare function markedSubSup(): {
-    extensions: {
-        name: string;
-        level: 'inline';
-        tokenizer: TokenizerExtensionFunction;
-        start?: TokenizerStartFunction;
-    }[];
-};
+import type { Extension } from './index.js';
+export declare const markedSub: Extension;
+export declare const markedSup: Extension;
 /**
  * Represents a subscript token.
  */

package/dist/marked/marked-subsup.js

@@ -1,45 +1,40 @@
 const subRule = /^~([^~\s](?:[^~]*[^~\s])?)~/; // ~text~
 const supRule = /^\^([^\^\s](?:[^\^]*[^\^\s])?)\^/; // ^text^
-export function markedSubSup() {
-    return {
-        extensions: [
-            {
-                name: 'sub',
-                level: 'inline',
-                start(src) {
-                    const i = src.indexOf('~');
-                    return i === -1 ? undefined : i;
-                },
-                tokenizer(src) {
-                    const match = src.match(subRule);
-                    if (match) {
-                        return {
-                            type: 'sub',
-                            raw: match[0],
-                            text: match[1],
-                            tokens: this.lexer.inlineTokens(match[1])
-                        };
-                    }
-                }
-            },
-            {
-                name: 'sup',
-                level: 'inline',
-                start(src) {
-                    return src.indexOf('^');
-                },
-                tokenizer(src) {
-                    const match = src.match(supRule);
-                    if (match) {
-                        return {
-                            type: 'sup',
-                            raw: match[0],
-                            text: match[1],
-                            tokens: this.lexer.inlineTokens(match[1])
-                        };
-                    }
-                }
-            }
-        ]
-    };
-}
+export const markedSub = {
+    name: 'sub',
+    level: 'inline',
+    start(src) {
+        const i = src.indexOf('~');
+        return i === -1 ? undefined : i;
+    },
+    tokenizer(src) {
+        const match = src.match(subRule);
+        if (match) {
+            return {
+                type: 'sub',
+                raw: match[0],
+                text: match[1],
+                tokens: this.lexer.inlineTokens(match[1])
+            };
+        }
+    }
+};
+export const markedSup = {
+    name: 'sup',
+    level: 'inline',
+    start(src) {
+        const i = src.indexOf('^');
+        return i === -1 ? undefined : i;
+    },
+    tokenizer(src) {
+        const match = src.match(supRule);
+        if (match) {
+            return {
+                type: 'sup',
+                raw: match[0],
+                text: match[1],
+                tokens: this.lexer.inlineTokens(match[1])
+            };
+        }
+    }
+};

package/dist/marked/marked-table.d.ts

@@ -1,4 +1,4 @@
-import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
+import type { Extension } from './index.js';
 export interface SpanTableOptions {
     useTheadTbody?: boolean;
     useTfoot?: boolean;
@@ -56,12 +56,5 @@ type WorkingRow = WorkingCell[];
 export declare const DEFAULT_OPTIONS: Required<SpanTableOptions>;
 export declare const getTableCell: (text: string, cell: BaseCell, type: "th" | "td", align: string | null) => string;
 export declare const splitCells: (tableRow: string, count: number | null, prevRow?: WorkingRow | null, maxColspan?: number | null) => WorkingRow;
-export declare function markedTable(options?: SpanTableOptions): {
-    extensions: {
-        name: string;
-        level: 'block' | 'inline';
-        start: TokenizerStartFunction;
-        tokenizer: TokenizerExtensionFunction;
-    }[];
-};
+export declare const markedTable: Extension;
 export {};