svelte-streamdown 1.0.7 → 1.0.9

package/dist/marked/index.js

@@ -2,6 +2,8 @@ import { Lexer, marked } from 'marked';
 import markedAlert, {} from './marked-alert.js';
 import markedFootnote, {} from './marked-footnotes.js';
 import { markedMath } from './marked-math.js';
+import markedSubSup, {} from './marked-subsup.js';
+import { markedList } from './marked-list.js';
 export const lex = (markdown) => {
     return marked
         .use({
@@ -10,6 +12,8 @@ export const lex = (markdown) => {
         .use(markedAlert())
         .use(markedFootnote())
         .use(markedMath())
+        .use(markedSubSup())
+        .use(markedList())
         .lexer(markdown)
         .filter((token) => token.type !== 'space' && token.type !== 'footnote');
 };

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

@@ -1,4 +1,4 @@
-import type { Token } from 'marked';
+import type { Token, Tokenizer } from 'marked';
 import type { TokenizerExtensionFunction } from 'marked';
 type variantType = 'note' | 'tip' | 'important' | 'warning' | 'caution';
 export declare function createSyntaxPattern(type: variantType): string;
@@ -9,7 +9,7 @@ export default function markedAlert(): {
         tokenizer: TokenizerExtensionFunction;
     }>;
 };
-export declare function processAlertToken(token: Token): void;
+export declare function processAlertToken(token: Token, tokenizer: Tokenizer): void;
 export type AlertToken = {
     type: 'alert';
     variant: variantType;

package/dist/marked/marked-alert.js

@@ -15,7 +15,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,7 +23,7 @@ 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;
@@ -35,20 +35,20 @@ export function processAlertToken(token) {
     });
     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();
-    }
+    const lines = token.raw
+        .split('>')
+        .filter((line) => line.trim().replace(typeRegexp, '').length > 0);
+    const tokens = lines.map((line) => {
+        const lineTokens = tokenizer.lexer.inlineTokens(line);
+        return {
+            type: 'paragraph',
+            tokens: lineTokens
+        };
+    });
+    // Transform the token into an alert token
+    Object.assign(token, {
+        type: 'alert',
+        variant: matchedVariant,
+        tokens
+    });
 }

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.svelte';
+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);
@@ -54,6 +72,7 @@ export default function markedFootnote() {
                     if (match) {
                         const [raw, label] = match;
                         const footnote = maps.footnotes.get(label);
+                        console.log({ footnote });
                         const token = {
                             type: 'footnoteRef',
                             raw,
@@ -62,6 +81,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';
+    loose: boolean;
+    items: 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,215 @@
+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.items.length === 0)
+        return;
+    // Trim trailing newline from last item
+    const lastItem = list.items[list.items.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.items) {
+        lexer.state.top = false;
+        item.tokens = lexer.blockTokens(item.text, []);
+    }
+    // Mark list as loose if needed
+    if (list.loose) {
+        for (const item of list.items) {
+            item.loose = true;
+        }
+    }
+}
+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 = 1;
+                    // 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 : '[*+-]';
+                    }
+                    const list = {
+                        type: 'list',
+                        raw: '',
+                        ordered: isOrdered,
+                        listType: type,
+                        loose: false,
+                        items: []
+                    };
+                    // 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));
+                        }
+                        list.items.push({
+                            type: 'list_item',
+                            raw,
+                            task: !!isTask,
+                            checked: isChecked,
+                            loose: false,
+                            text: itemContents,
+                            value,
+                            skipped: isOrdered && value !== expectedValue,
+                            tokens: []
+                        });
+                        expectedValue = (value ?? 0) + 1;
+                        list.raw += raw;
+                    }
+                    if (list.items.length === 0)
+                        return null;
+                    // Finalize the list
+                    finalizeList(list, this.lexer);
+                    return list;
+                }
+            }
+        ]
+    };
+}

package/dist/marked/marked-math.js

@@ -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 | void;
+    }[];
+};
+/**
+ * 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,44 @@
+const subRule = /^~([^~\s](?:[^~]*[^~\s])?)~/; // ~text~
+const supRule = /^\^([^\^\s](?:[^\^]*[^\^\s])?)\^/; // ^text^
+export default function markedSubSup() {
+    return {
+        extensions: [
+            {
+                name: 'sub',
+                level: 'inline',
+                start(src) {
+                    return src.indexOf('~');
+                },
+                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])
+                        };
+                    }
+                }
+            }
+        ]
+    };
+}