svelte-streamdown 2.3.1 → 2.3.2

package/dist/marked/marked-footnotes.js

@@ -26,69 +26,66 @@ export function markedFootnote() {
             return streamdown.footnotes;
         }
     };
-    return {
-        extensions: [
-            {
-                name: 'footnote',
-                level: 'block',
-                tokenizer(src) {
-                    const maps = ensureMaps(this);
-                    const match = /^\[\^([^\]\n]+)\]:(?:[ \t]+|[\n]*?|$)([^\n]*?(?:\n|$)(?:\n*?[ ]{4,}[^\n]*)*)/.exec(src);
-                    if (match) {
-                        const [raw, label, text = ''] = match;
-                        let content = text.split('\n').reduce((acc, curr) => {
-                            return acc + '\n' + curr.replace(/^(?:[ ]{4}|[\t])/, '');
-                        }, '');
-                        const contentLastLine = content.trimEnd().split('\n').pop();
-                        content +=
-                            // add lines after list, blockquote, codefence, and table
-                            contentLastLine &&
-                                /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/.test(contentLastLine)
-                                ? '\n\n'
-                                : '';
-                        const lines = content.split('\n');
-                        const token = {
+    return [
+        {
+            name: 'footnote',
+            level: 'block',
+            tokenizer(src) {
+                const maps = ensureMaps(this);
+                const match = /^\[\^([^\]\n]+)\]:(?:[ \t]+|[\n]*?|$)([^\n]*?(?:\n|$)(?:\n*?[ ]{4,}[^\n]*)*)/.exec(src);
+                if (match) {
+                    const [raw, label, text = ''] = match;
+                    let content = text.split('\n').reduce((acc, curr) => {
+                        return acc + '\n' + curr.replace(/^(?:[ ]{4}|[\t])/, '');
+                    }, '');
+                    const contentLastLine = content.trimEnd().split('\n').pop();
+                    content +=
+                        // add lines after list, blockquote, codefence, and table
+                        contentLastLine && /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/.test(contentLastLine)
+                            ? '\n\n'
+                            : '';
+                    const lines = content.split('\n');
+                    const token = {
+                        type: 'footnote',
+                        raw,
+                        label,
+                        lines,
+                        tokens: []
+                    };
+                    maps.footnotes.set(label, token);
+                    const ref = maps.refs.get(label);
+                    if (ref) {
+                        ref.content = token;
+                    }
+                    return token;
+                }
+            }
+        },
+        {
+            name: 'footnoteRef',
+            level: 'inline',
+            tokenizer(src) {
+                const maps = ensureMaps(this);
+                const match = /^\[\^([^\]\n]+)\]/.exec(src);
+                if (match) {
+                    const [raw, label] = match;
+                    const footnote = maps.footnotes.get(label);
+                    const token = {
+                        type: 'footnoteRef',
+                        raw,
+                        label,
+                        content: footnote || {
                             type: 'footnote',
                             raw,
                             label,
-                            lines,
+                            lines: [],
                             tokens: []
-                        };
-                        maps.footnotes.set(label, token);
-                        const ref = maps.refs.get(label);
-                        if (ref) {
-                            ref.content = token;
                         }
-                        return token;
-                    }
-                }
-            },
-            {
-                name: 'footnoteRef',
-                level: 'inline',
-                tokenizer(src) {
-                    const maps = ensureMaps(this);
-                    const match = /^\[\^([^\]\n]+)\]/.exec(src);
-                    if (match) {
-                        const [raw, label] = match;
-                        const footnote = maps.footnotes.get(label);
-                        const token = {
-                            type: 'footnoteRef',
-                            raw,
-                            label,
-                            content: footnote || {
-                                type: 'footnote',
-                                raw,
-                                label,
-                                lines: [],
-                                tokens: []
-                            }
-                        };
-                        maps.refs.set(label, token);
-                        return token;
-                    }
+                    };
+                    maps.refs.set(label, token);
+                    return token;
                 }
             }
-        ]
-    };
+        }
+    ];
 }

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

@@ -1,12 +1,6 @@
-import type { TokenizerExtensionFunction } from 'marked';
+import type { Extension } from './index.js';
 export interface HrToken {
     type: 'hr';
     raw: string;
 }
-export declare function markedHr(): {
-    extensions: Array<{
-        name: string;
-        level: 'block';
-        tokenizer: TokenizerExtensionFunction;
-    }>;
-};
+export declare const markedHr: Extension;

package/dist/marked/marked-hr.js

@@ -1,24 +1,18 @@
-export function markedHr() {
-    return {
-        extensions: [
-            {
-                name: 'hr',
-                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|$)/);
-                    if (match) {
-                        const raw = match[0].replace(/\n$/, ''); // Remove trailing newline from raw
-                        return {
-                            type: 'hr',
-                            raw: raw
-                        };
-                    }
-                    return undefined;
-                }
-            }
-        ]
-    };
-}
+export const markedHr = {
+    name: 'hr',
+    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|$)/);
+        if (match) {
+            const raw = match[0].replace(/\n$/, ''); // Remove trailing newline from raw
+            return {
+                type: 'hr',
+                raw: raw
+            };
+        }
+        return undefined;
+    }
+};

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

@@ -1,17 +1,11 @@
-import type { TokenizerExtensionFunction } from 'marked';
+import type { Extension, GenericToken } from './index.js';
 export declare function letterToInt(letter: string): number;
 export declare function romanToInt(roman: string): number;
 export declare const romanUpper = "(?:C|XC|L?X{0,3}(?:IX|IV|V?I{0,3}))";
 export declare const romanLower = "(?:c|xc|l?x{0,3}(?:ix|iv|v?i{0,3}))";
 export declare const bulletPattern = "(?:[*+-]|(?:\\d{1,9}|[a-zA-Z]|(?:C|XC|L?X{0,3}(?:IX|IV|V?I{0,3}))|(?:c|xc|l?x{0,3}(?:ix|iv|v?i{0,3})))[.)])";
 export declare const rule = "^( {0,3}(?:[*+-]|(?:\\d{1,9}|[a-zA-Z]|(?:C|XC|L?X{0,3}(?:IX|IV|V?I{0,3}))|(?:c|xc|l?x{0,3}(?:ix|iv|v?i{0,3})))[.)]))([ \\t][^\\n]*|[ \\t])?(?:\\n|$)";
-export declare function markedList(): {
-    extensions: Array<{
-        name: string;
-        level: 'block' | 'inline';
-        tokenizer: TokenizerExtensionFunction;
-    }>;
-};
+export declare const markedList: Extension;
 export interface ListToken {
     type: 'list';
     raw: string;
@@ -33,5 +27,5 @@ export interface ListItemToken {
     text: string;
     value: number | null;
     skipped: boolean;
-    tokens: unknown[];
+    tokens: GenericToken[];
 }

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;