svelte-streamdown 1.0.8 → 2.0.0

package/dist/marked/marked-alert.js

@@ -1,7 +1,10 @@
 import { Lexer } from 'marked';
 const variants = ['note', 'tip', 'important', 'warning', 'caution'];
+// export function createSyntaxPattern(type: variantType): string {
+// 	return `^(?:\\[!${type.toUpperCase()}])\\s*?\n*`;
+// }
 export function createSyntaxPattern(type) {
-    return `^(?:\\[!${type.toUpperCase()}])\\s*?\n*`;
+    return `^\\s*\\[!${type.toUpperCase()}\\]\\s+`;
 }
 export default function markedAlert() {
     const defaultLexer = new Lexer({ gfm: true });
@@ -15,7 +18,7 @@ export default function markedAlert() {
                     const cap = defaultTokenizer.rules.block.blockquote.exec(src);
                     if (cap) {
                         const blockquoteToken = defaultTokenizer.blockquote(src);
-                        blockquoteToken && processAlertToken(blockquoteToken);
+                        blockquoteToken && processAlertToken(blockquoteToken, this.lexer.options.tokenizer);
                         return blockquoteToken;
                     }
                 }
@@ -23,32 +26,16 @@ export default function markedAlert() {
         ]
     };
 }
-export function processAlertToken(token) {
+export function processAlertToken(token, tokenizer) {
     const matchedVariant = variants.find((type) => new RegExp(createSyntaxPattern(type)).test(('text' in token && token.text) || ''));
     if (!matchedVariant)
         return;
-    const typeRegexp = new RegExp(createSyntaxPattern(matchedVariant));
-    // Transform the token into an alert token
+    const tokens = token.tokens.map((token) => {
+        return tokenizer.lexer.blockTokens(token.raw.replaceAll(`[!${matchedVariant.toUpperCase()}]`, '').trim(), [])[0];
+    });
     Object.assign(token, {
         type: 'alert',
-        variant: matchedVariant
+        variant: matchedVariant,
+        tokens
     });
-    const firstLine = ('tokens' in token && token.tokens?.[0]);
-    const firstLineText = firstLine.raw?.replace(typeRegexp, '').trim();
-    firstLine.text = firstLineText;
-    if (firstLineText) {
-        const patternToken = firstLine.tokens[0];
-        if (patternToken) {
-            Object.assign(patternToken, {
-                raw: patternToken.raw.replace(typeRegexp, ''),
-                text: patternToken.text.replace(typeRegexp, '')
-            });
-        }
-        if (firstLine.tokens[1]?.type === 'br') {
-            firstLine.tokens.splice(1, 1);
-        }
-    }
-    else if ('tokens' in token && token.tokens) {
-        token.tokens?.shift();
-    }
 }

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

@@ -15,6 +15,7 @@ export type Footnote = {
     raw: string;
     label: string;
     tokens: StreamdownToken[];
+    lines: string[];
 };
 /**
  * Represents a reference to a footnote.

package/dist/marked/marked-footnotes.js

@@ -1,14 +1,30 @@
 import { lex } from './index.js';
+import { StreamdownContext } from '../Streamdown.js';
+import { getContext } from 'svelte';
+const safeGetContext = () => {
+    try {
+        return getContext('streamdown');
+    }
+    catch (e) {
+        return null;
+    }
+};
 export default function markedFootnote() {
     const ensureMaps = (tokenizer) => {
-        if (!tokenizer.lexer.hasFootnotes) {
-            tokenizer.lexer.footnotes = {
-                refs: new Map(),
-                footnotes: new Map()
-            };
-            tokenizer.lexer.hasFootnotes = true;
+        const streamdown = safeGetContext();
+        if (!streamdown) {
+            if (!tokenizer.lexer.hasFootnotes) {
+                tokenizer.lexer.footnotes = {
+                    refs: new Map(),
+                    footnotes: new Map()
+                };
+                tokenizer.lexer.hasFootnotes = true;
+            }
+            return tokenizer.lexer.footnotes;
+        }
+        else {
+            return streamdown.footnotes;
         }
-        return tokenizer.lexer.footnotes;
     };
     return {
         extensions: [
@@ -30,11 +46,13 @@ export default function markedFootnote() {
                                 /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/.test(contentLastLine)
                                 ? '\n\n'
                                 : '';
+                        const lines = content.split('\n');
                         const token = {
                             type: 'footnote',
                             raw,
                             label,
-                            tokens: lex(content)
+                            lines,
+                            tokens: []
                         };
                         maps.footnotes.set(label, token);
                         const ref = maps.refs.get(label);
@@ -62,6 +80,7 @@ export default function markedFootnote() {
                                 type: 'footnote',
                                 raw,
                                 label,
+                                lines: [],
                                 tokens: []
                             }
                         };

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

@@ -0,0 +1,36 @@
+import type { TokenizerExtensionFunction } from 'marked';
+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]+?)?(?:\\n|$)";
+export declare function markedList(): {
+    extensions: Array<{
+        name: string;
+        level: 'block' | 'inline';
+        tokenizer: TokenizerExtensionFunction;
+    }>;
+};
+export interface ListToken {
+    type: 'list';
+    raw: string;
+    ordered: boolean;
+    listType: 'decimal' | 'lower-alpha' | 'upper-alpha' | 'lower-roman' | 'upper-roman' | null;
+    loose: boolean;
+    tokens: ListItemToken[];
+}
+/**
+ * Token representing an item in an extended list.
+ */
+export interface ListItemToken {
+    type: 'list_item';
+    raw: string;
+    task: boolean;
+    checked: boolean;
+    loose: boolean;
+    text: string;
+    value: number | null;
+    skipped: boolean;
+    tokens: unknown[];
+}

package/dist/marked/marked-list.js

@@ -0,0 +1,232 @@
+export function letterToInt(letter) {
+    return letter.toLowerCase().charCodeAt(0) - 96;
+}
+const romanMap = {
+    I: 1,
+    V: 5,
+    X: 10,
+    L: 50,
+    C: 100,
+    D: 500,
+    M: 1000
+};
+export function romanToInt(roman) {
+    roman = roman.toUpperCase();
+    let total = 0;
+    for (let i = 0; i < roman.length; i++) {
+        const current = romanMap[roman[i]];
+        const next = romanMap[roman[i + 1]];
+        total += next && current < next ? -current : current;
+    }
+    return total;
+}
+// Regular expression patterns for list detection
+export const romanUpper = '(?:C|XC|L?X{0,3}(?:IX|IV|V?I{0,3}))';
+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]+?)?(?:\\n|$)`;
+function finalizeList(list, lexer) {
+    if (list.tokens.length === 0)
+        return;
+    // Trim trailing newline from last item
+    const lastItem = list.tokens[list.tokens.length - 1];
+    lastItem.raw = lastItem.raw.trimEnd();
+    lastItem.text = lastItem.text.trimEnd();
+    list.raw = list.raw.trimEnd();
+    // Handle child tokens
+    for (const item of list.tokens) {
+        lexer.state.top = false;
+        item.tokens = lexer.blockTokens(item.text, []);
+    }
+    // Mark list as loose if needed
+    if (list.loose) {
+        for (const item of list.tokens) {
+            item.loose = true;
+        }
+    }
+}
+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)}`;
+                        }
+                    }
+                    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,
+                        tokens: []
+                    };
+                    // Get next list item
+                    const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\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].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;
+                            }
+                            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;
+                }
+            }
+        ]
+    };
+}

package/dist/marked/marked-math.js

@@ -1,6 +1,6 @@
 const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n\$]))\1(?=[\s?!\.,:？！。，：]|$)/;
 const inlineRuleNonStandard = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n\$]))\1/; // Non-standard, even if there are no spaces before and after $ or $$, try to parse
-const blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+const blockRule = /^(\${1,2})\n((?:\\[\s\S]|[^\\])+?)\n\1(?:\n|$)/;
 export function markedMath() {
     return {
         extensions: [
@@ -27,9 +27,6 @@ export function markedMath() {
                 },
                 tokenizer(src) {
                     const match = src.match(inlineRuleNonStandard);
-                    if (match) {
-                        console.log('match', match);
-                    }
                     if (match) {
                         return {
                             type: 'math',

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

@@ -0,0 +1,28 @@
+import type { TokenizerExtensionFunction } from 'marked';
+export default function markedSubSup(): {
+    extensions: {
+        name: string;
+        level: 'inline';
+        tokenizer: TokenizerExtensionFunction;
+        start?: (src: string) => number | undefined;
+    }[];
+};
+/**
+ * Represents a subscript token.
+ */
+export type SubToken = {
+    type: 'sub';
+    raw: string;
+    text: string;
+    tokens: any[];
+};
+/**
+ * Represents a superscript token.
+ */
+export type SupToken = {
+    type: 'sup';
+    raw: string;
+    text: string;
+    tokens: any[];
+};
+export type SubSupToken = SubToken | SupToken;

package/dist/marked/marked-subsup.js

@@ -0,0 +1,45 @@
+const subRule = /^~([^~\s](?:[^~]*[^~\s])?)~/; // ~text~
+const supRule = /^\^([^\^\s](?:[^\^]*[^\^\s])?)\^/; // ^text^
+export default 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])
+                        };
+                    }
+                }
+            }
+        ]
+    };
+}

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

@@ -0,0 +1,59 @@
+import type { MarkedExtension } from 'marked';
+export interface SpanTableOptions {
+    useTheadTbody?: boolean;
+    useTfoot?: boolean;
+    detectFooter?: boolean;
+    maxColspan?: number | null;
+    handleComplexSpans?: boolean;
+}
+interface BaseCell {
+    rowspan: number;
+    colspan: number;
+    text: string;
+    position?: number;
+    tokens?: unknown[];
+    rowSpanTarget?: BaseCell;
+    complexRowSpan?: boolean;
+    relatedCell?: BaseCell;
+    align?: string | null;
+}
+export interface TH extends BaseCell {
+    type: 'th';
+}
+export interface TD extends BaseCell {
+    type: 'td';
+}
+export interface THeadRow {
+    type: 'tr';
+    tokens: TH[];
+}
+export interface TRow {
+    type: 'tr';
+    tokens: TD[];
+}
+export interface THead {
+    type: 'thead';
+    tokens: THeadRow[];
+}
+export interface TBody {
+    type: 'tbody';
+    tokens: TRow[];
+}
+export interface TFoot {
+    type: 'tfoot';
+    tokens: TRow[];
+}
+export type TableSection = THead | TBody | TFoot;
+export interface TableToken {
+    type: 'table';
+    tokens: TableSection[];
+    raw: string;
+}
+interface WorkingCell extends BaseCell {
+}
+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): MarkedExtension;
+export {};