svelte-streamdown 1.0.9 → 2.0.1

package/dist/Streamdown.js

@@ -1 +1,19 @@
-export {};
+import { getContext, setContext } from 'svelte';
+export class StreamdownContext {
+    footnotes = {
+        refs: new Map(),
+        footnotes: new Map()
+    };
+    constructor(props) {
+        bind(this, props);
+        setContext('streamdown', this);
+    }
+}
+export const useStreamdown = () => {
+    const context = getContext('streamdown');
+    if (!context) {
+        throw new Error('Streamdown context not found');
+    }
+    return context;
+};
+import { bind } from './utils/bind.js';

package/dist/Streamdown.svelte

@@ -1,42 +1,10 @@
-<script lang="ts" module>
-	import { getContext, setContext } from 'svelte';
-
-	export interface StreamdownContext
-		extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'shikiTheme'> {
-		snippets: Snippets;
-		shikiTheme: BundledTheme;
-		theme: Theme;
-	}
-	export class StreamdownContext {
-		footnotes = {
-			refs: new Map<string, FootnoteRef>(),
-			footnotes: new Map<string, Footnote>()
-		};
-		constructor(props: Omit<StreamdownProps, keyof Snippets | 'class'> & { snippets: Snippets }) {
-			bind(this, props);
-			setContext('streamdown', this);
-		}
-	}
-	export const useStreamdown = () => {
-		const context = getContext<StreamdownContext>('streamdown');
-		if (!context) {
-			throw new Error('Streamdown context not found');
-		}
-		return context;
-	};
-</script>
-
 <script lang="ts">
 	import Block from './Block.svelte';
-	import type { Snippets, StreamdownProps } from './Streamdown.js';
-	import { bind } from './utils/bind.js';
+	import { StreamdownContext, type StreamdownProps } from './Streamdown.js';
 	import 'katex/dist/katex.min.css';
-	import { mergeTheme, type Theme, shadcnTheme } from './theme.js';
-	import type { BundledTheme } from 'shiki';
+	import { mergeTheme, shadcnTheme } from './theme.js';
 	import { parseBlocks } from './marked/index.js';
-	import { SvelteMap } from 'svelte/reactivity';
-	import type { FootnoteRef } from './marked/marked-footnotes.js';
-	import type { Footnote } from './marked/marked-footnotes.js';
+
 	let {
 		content = '',
 		class: className,
@@ -52,13 +20,10 @@
 		translations,
 		baseTheme,
 		mergeTheme: shouldMergeTheme = true,
-		customElements,
 		streamdown = $bindable(),
 		...snippets
 	}: StreamdownProps = $props();
 
-	console.log('render');
-
 	streamdown = new StreamdownContext({
 		get content() {
 			return content;
@@ -98,9 +63,6 @@
 		get translations() {
 			return translations;
 		},
-		get customElements() {
-			return customElements;
-		},
 		get shikiPreloadThemes() {
 			return shikiPreloadThemes;
 		}

package/dist/Streamdown.svelte.d.ts

@@ -1,24 +1,5 @@
-export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'shikiTheme'> {
-    snippets: Snippets;
-    shikiTheme: BundledTheme;
-    theme: Theme;
-}
-export declare class StreamdownContext {
-    footnotes: {
-        refs: Map<string, FootnoteRef>;
-        footnotes: Map<string, Footnote>;
-    };
-    constructor(props: Omit<StreamdownProps, keyof Snippets | 'class'> & {
-        snippets: Snippets;
-    });
-}
-export declare const useStreamdown: () => StreamdownContext;
-import type { Snippets, StreamdownProps } from './Streamdown.js';
+import { type StreamdownProps } from './Streamdown.js';
 import 'katex/dist/katex.min.css';
-import { type Theme } from './theme.js';
-import type { BundledTheme } from 'shiki';
-import type { FootnoteRef } from './marked/marked-footnotes.js';
-import type { Footnote } from './marked/marked-footnotes.js';
 declare const Streamdown: import("svelte").Component<StreamdownProps, {}, "streamdown">;
 type Streamdown = ReturnType<typeof Streamdown>;
 export default Streamdown;

package/dist/marked/index.d.ts

@@ -4,26 +4,9 @@ import { type FootnoteToken } from './marked-footnotes.js';
 import { type MathToken } from './marked-math.js';
 import { type SubSupToken } from './marked-subsup.js';
 import { type ListItemToken, type ListToken } from './marked-list.js';
-export type StreamdownToken = Exclude<MarkedToken, Tokens.List | Tokens.ListItem> | ListToken | ListItemToken | MathToken | AlertToken | FootnoteToken | SubSupToken | TableRow | TD | TH | TableHead;
-export type TD = Tokens.TableCell & {
-    type: 'td';
-    raw: string;
-};
-export type TH = Tokens.TableCell & {
-    type: 'th';
-    raw: string;
-};
-export type TableRow = {
-    type: 'tableRow';
-    raw: string;
-    tokens: (TD | TH)[];
-    isHeader: boolean;
-};
-export type TableHead = {
-    type: 'tableHead';
-    raw: string;
-    tokens: TableRow[];
-};
+import { type TableToken, type THead, type TBody, type TFoot, type THeadRow, type TRow, type TH, type TD } from './marked-table.js';
+export type StreamdownToken = Exclude<MarkedToken, Tokens.List | Tokens.ListItem> | ListToken | ListItemToken | MathToken | AlertToken | FootnoteToken | SubSupToken | TableToken | THead | TBody | TFoot | THeadRow | TRow | TH | TD;
+export type { TableToken, THead, TBody, TFoot, THeadRow, TRow, TH, TD } from './marked-table.js';
 export declare const lex: (markdown: string) => StreamdownToken[];
 export declare const parseBlocks: (markdown: string) => string[];
 export type { MathToken, AlertToken, FootnoteToken, SubSupToken };

package/dist/marked/index.js

@@ -1,32 +1,37 @@
-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({
+    tokenizer: {
+        table: () => {
+            return false;
+        }
+    }
+})
+    .use(markedAlert())
+    .use(markedFootnote())
+    .use(markedMath())
+    .use(markedSubSup())
+    .use(markedList())
+    .use(markedTable());
+const blockLexer = new Lexer({
+    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,7 @@
 import { Lexer } from 'marked';
 const variants = ['note', 'tip', 'important', 'warning', 'caution'];
 export function createSyntaxPattern(type) {
-    return `^(?:\\[!${type.toUpperCase()}])\\s*?\n*`;
+    return `^\\s*\\[!${type.toUpperCase()}\\]\\s+`;
 }
 export default function markedAlert() {
     const defaultLexer = new Lexer({ gfm: true });
@@ -11,7 +11,7 @@ export default function markedAlert() {
             {
                 name: 'alert',
                 level: 'block',
-                tokenizer(src, tokens) {
+                tokenizer(src) {
                     const cap = defaultTokenizer.rules.block.blockquote.exec(src);
                     if (cap) {
                         const blockquoteToken = defaultTokenizer.blockquote(src);
@@ -27,25 +27,11 @@ 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
-        };
-    });
-    // Transform the token into an alert token
+    const tokens = token.tokens
+        .map((token) => {
+        return tokenizer.lexer.blockTokens(token.raw.replaceAll(`[!${matchedVariant.toUpperCase()}]`, '').trim(), [])[0];
+    })
+        .filter(Boolean);
     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 {} from './index.js';
+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,66 @@
+import type { TokenizerExtensionFunction } 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): {
+    extensions: {
+        name: string;
+        level: 'block' | 'inline';
+        start: (src: string) => number | undefined;
+        tokenizer: TokenizerExtensionFunction;
+    }[];
+};
+export {};