svelte-streamdown 2.2.0 → 2.2.2

package/dist/AnimatedText.svelte

@@ -1,6 +1,5 @@
 <script lang="ts">
 	import { useStreamdown } from './streamdown.svelte.js';
-
 	let { text }: { text: string } = $props();
 
 	const streamdown = useStreamdown();
@@ -17,10 +16,7 @@
 
 		return text.split(splitRegex).filter((token) => token.length > 0);
 	};
-
-	let tokens = $derived.by(() => {
-		return tokenizeNewContent(text);
-	});
+	const tokens = $derived(tokenizeNewContent(text));
 
 	const isMounted = streamdown.isMounted;
 </script>

package/dist/Block.svelte

@@ -7,9 +7,11 @@
 	import AnimatedBlock from './AnimatedBlock.svelte';
 
 	let {
-		block
+		block,
+		insideFootnote = false
 	}: {
 		block: string;
+		insideFootnote?: boolean;
 	} = $props();
 	const id = $props.id();
 	const tokens = $derived(lex(parseIncompleteMarkdown(block.trim())));
@@ -23,7 +25,7 @@
 			{@const isTextOnlyNode = children.length === 0}
 			<Element {token}>
 				{#if isTextOnlyNode}
-					{#if streamdown.animation.enabled}
+					{#if streamdown.animation.enabled && !insideFootnote}
 						<AnimatedText text={'text' in token ? token.text : ''} />
 					{:else}
 						{'text' in token ? token.text : ''}
@@ -36,7 +38,7 @@
 	{/each}
 {/snippet}
 
-{#if streamdown.animation.enabled}
+{#if streamdown.animation.enabled && !insideFootnote}
 	<AnimatedBlock>
 		{@render renderChildren(tokens)}
 	</AnimatedBlock>

package/dist/Block.svelte.d.ts

@@ -1,5 +1,6 @@
 type $$ComponentProps = {
     block: string;
+    insideFootnote?: boolean;
 };
 declare const Block: import("svelte").Component<$$ComponentProps, {}, "">;
 type Block = ReturnType<typeof Block>;

package/dist/Elements/Element.svelte

@@ -12,6 +12,8 @@
 	import FootnoteRef from './FootnoteRef.svelte';
 	let { token, children }: { token: StreamdownToken; children: Snippet } = $props();
 	const streamdown = useStreamdown();
+
+	const isMounted = streamdown.isMounted;
 </script>
 
 {#if token.type === 'heading'}
@@ -91,6 +93,7 @@
 {:else if token.type === 'list_item'}
 	<Slot props={{ children, token }} render={streamdown.snippets.li}>
 		<li
+			style={isMounted ? streamdown.animationBlockStyle : undefined}
 			style:list-style-type={token.task ? 'none' : undefined}
 			{...token.value && !token.task ? { value: token.value } : {}}
 			class={streamdown.theme.li.base}

package/dist/Elements/FootnoteRef.svelte

@@ -100,7 +100,7 @@
 			class={`${streamdown.theme.footnotePopover.base}`}
 		>
 			{#each token.content.lines as line}
-				<Block block={line} />
+				<Block insideFootnote block={line} />
 			{/each}
 		</dialog>
 	</Slot>

package/dist/marked/index.js

@@ -1,33 +1,56 @@
-import { Lexer, Marked } from 'marked';
+import { Lexer } 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;
+const extensions = [
+    markedTable(),
+    markedFootnote(),
+    markedAlert(),
+    markedMath(),
+    markedSubSup(),
+    markedList()
+];
+const parseExtensions = (...ext) => {
+    const options = {
+        gfm: true,
+        extensions: {
+            block: [],
+            inline: [],
+            childTokens: {},
+            renderers: {},
+            startBlock: [],
+            startInline: []
         }
-    }
-})
-    .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]
-    }
-});
+    };
+    ext.forEach(({ extensions }) => {
+        extensions.forEach(({ level, name, tokenizer, ...rest }) => {
+            if ('start' in rest && rest.start) {
+                if (level === 'block') {
+                    options.extensions.startBlock.push(rest.start);
+                }
+                else {
+                    options.extensions.startInline.push(rest.start);
+                }
+            }
+            if (tokenizer) {
+                if (level === 'block') {
+                    options.extensions.block.push(tokenizer);
+                }
+                else {
+                    options.extensions.inline.push(tokenizer);
+                }
+            }
+        });
+    });
+    return options;
+};
+const blockLexer = new Lexer(parseExtensions(markedFootnote(), markedTable()));
 export const lex = (markdown) => {
-    return completeLexer
-        .lexer(markdown)
+    return new Lexer(parseExtensions(...extensions))
+        .lex(markdown)
         .filter((token) => token.type !== 'space' && token.type !== 'footnote');
 };
 export const parseBlocks = (markdown) => {

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

@@ -1,6 +1,11 @@
-import type { TokenizerAndRendererExtension } from 'marked';
+import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
 export declare function markedMath(): {
-    extensions: TokenizerAndRendererExtension<string, string>[];
+    extensions: Array<{
+        name: string;
+        level: 'block' | 'inline';
+        start?: TokenizerStartFunction;
+        tokenizer: TokenizerExtensionFunction;
+    }>;
 };
 export type MathToken = {
     type: 'math';

package/dist/marked/marked-math.js

@@ -1,9 +1,25 @@
-const inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n\$]))\1(?=[\s?!\.,:？！。，：]|$)/;
+// 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((?:\\[\s\S]|[^\\])+?)\n\1(?:\n|$)/;
 export function markedMath() {
     return {
         extensions: [
+            {
+                name: 'block-math',
+                level: 'block',
+                tokenizer(src) {
+                    const match = src.match(blockRule);
+                    if (match) {
+                        return {
+                            type: 'math',
+                            isInline: false,
+                            raw: match[0],
+                            text: match[2].trim()
+                        };
+                    }
+                }
+            },
             {
                 name: 'inline-math',
                 level: 'inline',
@@ -36,21 +52,6 @@ export function markedMath() {
                         };
                     }
                 }
-            },
-            {
-                name: 'block-math',
-                level: 'block',
-                tokenizer(src) {
-                    const match = src.match(blockRule);
-                    if (match) {
-                        return {
-                            type: 'math',
-                            isInline: false,
-                            raw: match[0],
-                            text: match[2].trim()
-                        };
-                    }
-                }
             }
         ]
     };

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

@@ -1,10 +1,10 @@
-import type { TokenizerExtensionFunction } from 'marked';
+import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
 export default function markedSubSup(): {
     extensions: {
         name: string;
         level: 'inline';
         tokenizer: TokenizerExtensionFunction;
-        start?: (src: string) => number | undefined;
+        start?: TokenizerStartFunction;
     }[];
 };
 /**

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

@@ -1,4 +1,4 @@
-import type { TokenizerExtensionFunction } from 'marked';
+import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
 export interface SpanTableOptions {
     useTheadTbody?: boolean;
     useTfoot?: boolean;
@@ -59,7 +59,7 @@ export declare function markedTable(options?: SpanTableOptions): {
     extensions: {
         name: string;
         level: 'block' | 'inline';
-        start: (src: string) => number | undefined;
+        start: TokenizerStartFunction;
         tokenizer: TokenizerExtensionFunction;
     }[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-streamdown",
-	"version": "2.2.0",
+	"version": "2.2.2",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",