svelte-streamdown 1.0.9 → 2.0.0

package/dist/marked/index.js

@@ -1,32 +1,40 @@
-import { Lexer, marked } from 'marked';
+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';
+import { markedTable } from './marked-table.js';
+const completeLexer = new Marked({
+    // Enable GFM features but disable built-in tables
+    gfm: true,
+    tokenizer: {
+        table: () => {
+            return false;
+        }
+    }
+})
+    .use(markedAlert())
+    .use(markedFootnote())
+    .use(markedMath())
+    .use(markedSubSup())
+    .use(markedList())
+    .use(markedTable());
+const blockLexer = new Lexer({
+    gfm: true,
+    extensions: {
+        childTokens: {},
+        renderers: {},
+        block: [markedFootnote().extensions[0].tokenizer, markedTable().extensions[0].tokenizer]
+    }
+});
 export const lex = (markdown) => {
-    return marked
-        .use({
-        gfm: true
-    })
-        .use(markedAlert())
-        .use(markedFootnote())
-        .use(markedMath())
-        .use(markedSubSup())
-        .use(markedList())
+    return completeLexer
         .lexer(markdown)
         .filter((token) => token.type !== 'space' && token.type !== 'footnote');
 };
 export const parseBlocks = (markdown) => {
-    const lexer = new Lexer({
-        gfm: true,
-        extensions: {
-            childTokens: {},
-            renderers: {},
-            block: [markedFootnote().extensions[0].tokenizer]
-        }
-    });
-    return lexer.blockTokens(markdown, []).reduce((acc, block) => {
+    return blockLexer.blockTokens(markdown, []).reduce((acc, block) => {
         if (block.type === 'space' || block.type === 'footnote') {
             return acc;
         }

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

@@ -1,4 +1,4 @@
-import type { Token, Tokenizer } from 'marked';
+import type { Tokenizer, Tokens } 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, tokenizer: Tokenizer): void;
+export declare function processAlertToken(token: Tokens.Blockquote, tokenizer: Tokenizer): void;
 export type AlertToken = {
     type: 'alert';
     variant: variantType;

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 });
@@ -27,25 +30,9 @@ 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
-    Object.assign(token, {
-        type: 'alert',
-        variant: matchedVariant
-    });
-    const firstLine = ('tokens' in token && token.tokens?.[0]);
-    const firstLineText = firstLine.raw?.replace(typeRegexp, '').trim();
-    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
-        };
+    const tokens = token.tokens.map((token) => {
+        return tokenizer.lexer.blockTokens(token.raw.replaceAll(`[!${matchedVariant.toUpperCase()}]`, '').trim(), [])[0];
     });
-    // Transform the token into an alert token
     Object.assign(token, {
         type: 'alert',
         variant: matchedVariant,

package/dist/marked/marked-footnotes.js

@@ -1,5 +1,5 @@
 import { lex } from './index.js';
-import { StreamdownContext } from '../Streamdown.svelte';
+import { StreamdownContext } from '../Streamdown.js';
 import { getContext } from 'svelte';
 const safeGetContext = () => {
     try {
@@ -72,7 +72,6 @@ export default function markedFootnote() {
                     if (match) {
                         const [raw, label] = match;
                         const footnote = maps.footnotes.get(label);
-                        console.log({ footnote });
                         const token = {
                             type: 'footnoteRef',
                             raw,

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

@@ -16,9 +16,9 @@ export interface ListToken {
     type: 'list';
     raw: string;
     ordered: boolean;
-    listType: 'decimal' | 'lower-alpha' | 'upper-alpha' | 'lower-roman' | 'upper-roman';
+    listType: 'decimal' | 'lower-alpha' | 'upper-alpha' | 'lower-roman' | 'upper-roman' | null;
     loose: boolean;
-    items: ListItemToken[];
+    tokens: ListItemToken[];
 }
 /**
  * Token representing an item in an extended list.

package/dist/marked/marked-list.js

@@ -27,25 +27,28 @@ export const romanLower = '(?:c|xc|l?x{0,3}(?:ix|iv|v?i{0,3}))';
 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)
+    if (list.tokens.length === 0)
         return;
     // Trim trailing newline from last item
-    const lastItem = list.items[list.items.length - 1];
+    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.items) {
+    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.items) {
+        for (const item of list.tokens) {
             item.loose = true;
         }
     }
 }
+function escapeForRegex(s) {
+    return s.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+}
 export function markedList() {
     return {
         extensions: [
@@ -60,7 +63,7 @@ export function markedList() {
                     const isOrdered = bullet !== '*' && bullet !== '-' && bullet !== '+';
                     let bull;
                     let type = '';
-                    let expectedValue = 1;
+                    let expectedValue = null;
                     // Detect list type (Roman, alphabetic, numeric)
                     if (isOrdered) {
                         if (bullet.match(new RegExp(`^${romanUpper}[.)]$`))) {
@@ -86,14 +89,15 @@ export function markedList() {
                     }
                     else {
                         bull = this.lexer.options.pedantic ? bullet : '[*+-]';
+                        bull = this.lexer.options.pedantic ? escapeForRegex(bullet) : '[*+-]';
                     }
                     const list = {
                         type: 'list',
                         raw: '',
                         ordered: isOrdered,
-                        listType: type,
+                        listType: isOrdered ? type : null,
                         loose: false,
-                        items: []
+                        tokens: []
                     };
                     // Get next list item
                     const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`);
@@ -189,7 +193,21 @@ export function markedList() {
                         else if (type === 'lower-roman' || type === 'upper-roman') {
                             value = romanToInt(bullet.slice(0, -1));
                         }
-                        list.items.push({
+                        // 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,
@@ -197,13 +215,12 @@ export function markedList() {
                             loose: false,
                             text: itemContents,
                             value,
-                            skipped: isOrdered && value !== expectedValue,
+                            skipped,
                             tokens: []
                         });
-                        expectedValue = (value ?? 0) + 1;
                         list.raw += raw;
                     }
-                    if (list.items.length === 0)
+                    if (list.tokens.length === 0)
                         return null;
                     // Finalize the list
                     finalizeList(list, this.lexer);

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: [

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

@@ -4,7 +4,7 @@ export default function markedSubSup(): {
         name: string;
         level: 'inline';
         tokenizer: TokenizerExtensionFunction;
-        start?: (src: string) => number | void;
+        start?: (src: string) => number | undefined;
     }[];
 };
 /**

package/dist/marked/marked-subsup.js

@@ -7,7 +7,8 @@ export default function markedSubSup() {
                 name: 'sub',
                 level: 'inline',
                 start(src) {
-                    return src.indexOf('~');
+                    const i = src.indexOf('~');
+                    return i === -1 ? undefined : i;
                 },
                 tokenizer(src) {
                     const match = src.match(subRule);

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 {};