svelte-streamdown 3.1.2 → 4.0.1

package/dist/theme.d.ts

@@ -42,7 +42,6 @@ export declare const theme: {
         header: string;
         buttons: string;
         language: string;
-        skeleton: string;
         pre: string;
         line: string;
     };
@@ -195,7 +194,6 @@ export declare const shadcnTheme: {
         header: string;
         buttons: string;
         language: string;
-        skeleton: string;
         pre: string;
         line: string;
     };
@@ -353,7 +351,6 @@ export declare const mergeTheme: (customTheme?: DeepPartialTheme, baseTheme?: "t
         header: string;
         buttons: string;
         language: string;
-        skeleton: string;
         pre: string;
         line: string;
     };

package/dist/theme.js

@@ -43,7 +43,6 @@ export const theme = {
         header: 'flex items-center justify-between bg-gray-100/80 p-2	 text-gray-600 text-xs',
         buttons: 'flex items-center gap-2',
         language: 'ml-1 font-mono lowercase',
-        skeleton: 'block rounded-md font-mono text-transparent bg-gray-200 scale-y-90 animate-pulse whitespace-nowrap',
         pre: 'overflow-x-auto font-mono p-0 bg-gray-100/40',
         line: 'block'
     },
@@ -196,7 +195,6 @@ export const shadcnTheme = {
         header: 'flex items-center justify-between bg-muted/80 px-2 py-1 text-muted-foreground text-xs',
         buttons: 'flex items-center gap-2',
         language: 'ml-1 font-mono lowercase',
-        skeleton: 'block rounded-md font-mono text-transparent bg-border/80 scale-y-90 w-fit animate-pulse whitespace-nowrap',
         pre: 'overflow-x-auto font-mono p-0 bg-muted/40',
         line: 'block '
     },

package/dist/utils/highlightThemes.d.ts

@@ -0,0 +1,4 @@
+import type { HighlightTheme } from '@tanstack/highlight/theme';
+export declare const DEFAULT_THEMES: Record<string, HighlightTheme>;
+/** Resolves the active theme: explicit key, else the first user theme, else the dark-mode default. */
+export declare function resolveHighlightTheme(key: string | undefined, extra: Record<string, HighlightTheme> | undefined, isDark: boolean): HighlightTheme;

package/dist/utils/highlightThemes.js

@@ -0,0 +1,14 @@
+import githubDark from '@tanstack/highlight/themes/github-dark';
+import githubLight from '@tanstack/highlight/themes/github-light';
+// ponytail: themes live apart from the highlighter so <Streamdown> never pulls in the
+// language scanners — those are only reachable from the opt-in <Code> component.
+export const DEFAULT_THEMES = {
+    'github-dark': githubDark,
+    'github-light': githubLight
+};
+/** Resolves the active theme: explicit key, else the first user theme, else the dark-mode default. */
+export function resolveHighlightTheme(key, extra, isDark) {
+    const themes = { ...DEFAULT_THEMES, ...extra };
+    const fallback = DEFAULT_THEMES[isDark ? 'github-dark' : 'github-light'];
+    return themes[key ?? (extra ? Object.keys(extra)[0] : fallback.name)] ?? fallback;
+}

package/dist/utils/hightlighter.svelte.d.ts

@@ -1,30 +1,7 @@
-import type { ThemedToken, ThemeRegistration } from 'shiki';
-import type { HighlighterCore } from 'shiki/core';
-import { SvelteMap } from 'svelte/reactivity';
-import { type LanguageInfo } from './bundledLanguages.js';
-export type Highlighter = HighlighterCore;
-declare class HighlighterManager {
-    loadedLanguages: SvelteMap<string, boolean | Promise<void>>;
-    highlighter: any;
-    customLanguages: Set<string>;
-    languageLoaders: Map<string, () => Promise<any>>;
-    additionalThemes: Record<string, ThemeRegistration>;
-    constructor(languages: LanguageInfo[], additionalThemes?: Record<string, ThemeRegistration>, additionalLanguages?: LanguageInfo[]);
-    private loadHighlighter;
-    private isThemeAvailable;
-    private loadLanguage;
-    private isLanguageSupported;
-    isReady(theme: string, language: string | undefined): boolean;
-    /**
-     * Ensures the highlighter is ready for the given theme and language.
-     */
-    load(theme: string, language: string | undefined): Promise<void>;
-    /**
-     * Highlights code synchronously. Must call isReady() first.
-     * Returns plaintext tokens for unsupported languages.
-     */
-    highlightCode(code: string, language: string | undefined, theme: string): ThemedToken[][];
-    static create(languages?: LanguageInfo[], additionalThemes?: Record<string, ThemeRegistration>, additionalLanguages?: LanguageInfo[]): HighlighterManager;
-}
-export { HighlighterManager };
+import { type HighlightToken, type LanguageDefinition } from '@tanstack/highlight';
+/**
+ * Tokenizes code into lines of tokens. Synchronous and isomorphic: works during SSR.
+ * Unknown languages fall back to plaintext.
+ */
+export declare function highlightLines(code: string, lang: string | undefined, extra?: LanguageDefinition[]): HighlightToken[][];
 export declare const languageExtensionMap: Record<string, string>;

package/dist/utils/hightlighter.svelte.js

@@ -1,219 +1,34 @@
-import { SvelteMap } from 'svelte/reactivity';
-import { supportedLanguages, createLanguageSet, bundledLanguagesInfo } from './bundledLanguages.js';
-import { createHighlighterCore } from 'shiki/core';
-import { createJavaScriptRegexEngine } from 'shiki/engine/javascript';
-// Import default themes directly
-import githubDark from '@shikijs/themes/github-dark';
-import githubLight from '@shikijs/themes/github-light';
-// Default themes that are always loaded
-const DEFAULT_THEMES = {
-    'github-dark': githubDark,
-    'github-light': githubLight
-};
-class HighlighterManager {
-    loadedLanguages = new SvelteMap();
-    highlighter = $state(null);
-    customLanguages;
-    languageLoaders;
-    additionalThemes;
-    constructor(languages, additionalThemes, additionalLanguages) {
-        // Store additional themes (will be loaded with highlighter)
-        this.additionalThemes = additionalThemes || {};
-        // Merge languages: default + additional
-        const allLanguages = additionalLanguages ? [...languages, ...additionalLanguages] : languages;
-        this.languageLoaders = new Map();
-        allLanguages.forEach((l) => {
-            this.languageLoaders.set(l.id, l.import);
-            if (l.aliases) {
-                l.aliases.forEach((alias) => this.languageLoaders.set(alias, l.import));
-            }
-        });
-        // Build custom languages set for validation
-        if (additionalLanguages) {
-            const additionalSet = createLanguageSet(additionalLanguages);
-            this.customLanguages = new Set([...supportedLanguages, ...additionalSet]);
-        }
-        else {
-            this.customLanguages = supportedLanguages;
-        }
-        if (typeof window !== 'undefined') {
-            Object.assign(window, {
-                STREAMDOWN_HIGHLIGHTER: this
-            });
-        }
-    }
-    async loadHighlighter() {
-        if (this.highlighter instanceof Promise) {
-            return this.highlighter;
-        }
-        else if (!this.highlighter) {
-            this.highlighter = new Promise(async (resolve, reject) => {
-                try {
-                    const engine = createJavaScriptRegexEngine({ forgiving: true });
-                    // Load default themes + any additional themes immediately
-                    const allThemes = [
-                        ...Object.values(DEFAULT_THEMES),
-                        ...Object.values(this.additionalThemes)
-                    ];
-                    const highlighter = await createHighlighterCore({
-                        themes: allThemes,
-                        langs: [],
-                        engine
-                    });
-                    this.highlighter = highlighter;
-                    resolve(highlighter);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            return this.highlighter;
-        }
-        else {
-            return this.highlighter;
-        }
-    }
-    isThemeAvailable(theme) {
-        return theme in DEFAULT_THEMES || theme in this.additionalThemes;
+import { createHighlighter, defaultHighlighter, allLanguages } from '@tanstack/highlight';
+const highlighters = new WeakMap();
+const getHighlighter = (extra) => {
+    if (!extra?.length)
+        return defaultHighlighter;
+    let highlighter = highlighters.get(extra);
+    if (!highlighter) {
+        highlighter = createHighlighter({ languages: [...allLanguages, ...extra] });
+        highlighters.set(extra, highlighter);
     }
-    async loadLanguage(language, highlighter) {
-        // Skip loading if language is not supported
-        if (!this.isLanguageSupported(language)) {
-            return;
-        }
-        const languageLoader = this.loadedLanguages.get(language);
-        if (languageLoader instanceof Promise) {
-            await languageLoader;
-        }
-        else if (!languageLoader) {
-            const loader = this.languageLoaders.get(language);
-            if (!loader) {
-                // Language not available, mark as failed
-                this.loadedLanguages.set(language, false);
-                return;
-            }
-            const languageLoaderPromise = loader()
-                .then((langModule) => {
-                const langObj = langModule.default || langModule;
-                return highlighter.loadLanguage(langObj);
-            })
-                .then(() => {
-                this.loadedLanguages.set(language, true);
-            })
-                .catch((err) => {
-                this.loadedLanguages.set(language, false);
-                throw err;
-            });
-            this.loadedLanguages.set(language, languageLoaderPromise);
-            await languageLoaderPromise;
-        }
-    }
-    isLanguageSupported = (language) => {
-        return this.customLanguages.has(language);
-    };
-    isReady(theme, language) {
-        // Check if theme is available
-        if (!this.isThemeAvailable(theme)) {
-            return false;
-        }
-        // For unsupported languages, we don't need to load anything (will use plaintext)
-        if (!language || !this.isLanguageSupported(language)) {
-            return !!this.highlighter && !(this.highlighter instanceof Promise);
-        }
-        return (!!this.highlighter &&
-            !(this.highlighter instanceof Promise) &&
-            this.loadedLanguages.get(language) === true);
-    }
-    /**
-     * Ensures the highlighter is ready for the given theme and language.
-     */
-    async load(theme, language) {
-        // For unsupported languages, only need to load highlighter (themes are pre-loaded)
-        if (!language || !this.isLanguageSupported(language)) {
-            if (this.highlighter !== null && !(this.highlighter instanceof Promise)) {
-                return;
-            }
-            await this.loadHighlighter();
-            return;
-        }
-        const languageLoader = this.loadedLanguages.get(language);
-        if (this.highlighter !== null &&
-            !(this.highlighter instanceof Promise) &&
-            languageLoader === true) {
-            return;
-        }
-        const highlighter = await this.loadHighlighter();
-        await this.loadLanguage(language, highlighter);
-    }
-    /**
-     * Highlights code synchronously. Must call isReady() first.
-     * Returns plaintext tokens for unsupported languages.
-     */
-    highlightCode(code, language, theme) {
-        try {
-            const highlighter = this.highlighter;
-            if (!highlighter || highlighter instanceof Promise) {
-                // Return plaintext tokens when highlighter is not ready
-                return code.split('\n').map((line) => [
-                    {
-                        content: line,
-                        color: undefined,
-                        bgColor: undefined
-                    }
-                ]);
-            }
-            // For unsupported languages, return plaintext tokens
-            if (!language || !this.isLanguageSupported(language)) {
-                return code.split('\n').map((line) => [
-                    {
-                        content: line,
-                        color: undefined,
-                        bgColor: undefined
-                    }
-                ]);
-            }
-            const tokens = highlighter.codeToTokensBase(code, {
-                lang: language,
-                theme
-            });
-            return tokens;
-        }
-        catch (error) {
-            // Return plaintext tokens on error
-            return code.split('\n').map((line) => [
-                {
-                    content: line,
-                    color: undefined,
-                    bgColor: undefined
-                }
-            ]);
-        }
-    }
-    static create(languages = bundledLanguagesInfo, additionalThemes, additionalLanguages) {
-        if (typeof window !== 'undefined' && 'STREAMDOWN_HIGHLIGHTER' in window) {
-            const previousHighlighter = window.STREAMDOWN_HIGHLIGHTER;
-            // Merge additional themes
-            if (additionalThemes) {
-                Object.assign(previousHighlighter.additionalThemes, additionalThemes);
-            }
-            // Merge additional languages with existing set
-            if (additionalLanguages) {
-                additionalLanguages.forEach((lang) => {
-                    previousHighlighter.languageLoaders.set(lang.id, lang.import);
-                    if (lang.aliases) {
-                        lang.aliases.forEach((alias) => previousHighlighter.languageLoaders.set(alias, lang.import));
-                    }
-                });
-                const additionalSet = createLanguageSet(additionalLanguages);
-                additionalSet.forEach((lang) => previousHighlighter.customLanguages.add(lang));
-            }
-            return previousHighlighter;
+    return highlighter;
+};
+/**
+ * Tokenizes code into lines of tokens. Synchronous and isomorphic: works during SSR.
+ * Unknown languages fall back to plaintext.
+ */
+export function highlightLines(code, lang, extra) {
+    const tokens = getHighlighter(extra).tokenize(code, { lang }).tokens;
+    const lines = [[]];
+    for (const token of tokens) {
+        const parts = token.value.split('\n');
+        for (let i = 0; i < parts.length; i++) {
+            if (i > 0)
+                lines.push([]);
+            // ponytail: empty segments carry no text, so skip them instead of emitting empty spans
+            if (parts[i])
+                lines[lines.length - 1].push({ ...token, value: parts[i] });
         }
-        return new HighlighterManager(languages, additionalThemes, additionalLanguages);
     }
+    return lines;
 }
-// Export the class for those who want to create their own instances
-export { HighlighterManager };
 export const languageExtensionMap = {
     '1c': '1c',
     '1c-query': '1cq',

package/dist/utils/parse-incomplete-markdown.js

@@ -98,6 +98,20 @@ export class IncompleteMarkdownParser {
     // Create default plugins that replicate the original handler functions
     static createDefaultPlugins() {
         return [
+            {
+                // Runs first: in a list item a '>' before a number is a comparison
+                // ('- > 25: rich'), but marked reads it as a nested blockquote. Escaping it
+                // keeps the text, and the escape renders as a plain '>' (4fffb9f).
+                // `pattern` is only a cheap gate — a line whose first non-space character is
+                // not a list marker can never match, and bails on that one character.
+                name: 'comparisonOperator',
+                pattern: /^\s*[-*+\d]/,
+                skipInBlockTypes: ['code', 'math'],
+                handler: ({ line }) => {
+                    const match = listItemComparison.exec(line);
+                    return match ? `${match[1]}\\>${line.slice(match[0].length)}` : line;
+                }
+            },
             // Block-level plugin that manages blocking contexts
             {
                 name: 'contextManager',
@@ -172,7 +186,9 @@ export class IncompleteMarkdownParser {
                         result += '\n```';
                     }
                     if (state.blockingContexts.has('math')) {
-                        result += '\n$$';
+                        // The first half of the closing '$$' may already have arrived: adding a
+                        // whole '\n$$' would leave a stray '$' inside the math and '$$' after it.
+                        result += result.endsWith('$') && !result.endsWith('$$') ? '$' : '\n$$';
                     }
                     if (state.blockingContexts.has('center')) {
                         result += '\n[/center]';
@@ -195,6 +211,8 @@ export class IncompleteMarkdownParser {
                     const tripleAsterisks = (line.match(/\*\*\*/g) || []).length;
                     if (tripleAsterisks % 2 === 1) {
                         const lastTripleAsteriskIndex = line.lastIndexOf('***');
+                        if (isWithinCompleteInlineCode(line, lastTripleAsteriskIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastTripleAsteriskIndex);
                         if (isEndingWithTripleAsterisk) {
                             return line.substring(0, lastTripleAsteriskIndex);
@@ -222,6 +240,8 @@ export class IncompleteMarkdownParser {
                     if (doubleAsteriskMatches % 2 === 1) {
                         const isEndingWithDoubleAsterisk = line.endsWith('**');
                         const lastDoubleAsteriskIndex = line.lastIndexOf('**');
+                        if (isWithinCompleteInlineCode(line, lastDoubleAsteriskIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleAsteriskIndex);
                         if (isEndingWithDoubleAsterisk) {
                             return line.substring(0, lastDoubleAsteriskIndex);
@@ -248,6 +268,8 @@ export class IncompleteMarkdownParser {
                     if (underscorePairs % 2 === 1) {
                         const isEndingWithDoubleUnderscore = line.endsWith('__');
                         const lastDoubleUnderscoreIndex = line.lastIndexOf('__');
+                        if (isWithinCompleteInlineCode(line, lastDoubleUnderscoreIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleUnderscoreIndex);
                         if (isEndingWithDoubleUnderscore) {
                             return line.substring(0, lastDoubleUnderscoreIndex);
@@ -270,6 +292,8 @@ export class IncompleteMarkdownParser {
                     if (tildePairs % 2 === 1) {
                         const isEndingWithDoubleTilde = line.endsWith('~~');
                         const lastDoubleTildeIndex = line.lastIndexOf('~~');
+                        if (isWithinCompleteInlineCode(line, lastDoubleTildeIndex))
+                            return line;
                         const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastDoubleTildeIndex);
                         // Only complete if there's content after the tildes
                         const contentAfterTildes = line.substring(lastDoubleTildeIndex + 2, endOfCellOrLine);
@@ -296,37 +320,43 @@ export class IncompleteMarkdownParser {
                     }
                     // Inline countSingleAsterisks logic
                     let singleAsterisks = 0;
+                    let lastSingleAsterisk = -1;
                     for (let i = 0; i < line.length; i++) {
                         if (line[i] === '*') {
                             const prevChar = i > 0 ? line[i - 1] : '';
                             const nextChar = i < line.length - 1 ? line[i + 1] : '';
-                            let lineStartIndex = i;
-                            for (let j = i - 1; j >= 0; j--) {
-                                if (line[j] === '\n') {
-                                    lineStartIndex = j + 1;
-                                    break;
-                                }
-                                if (j === 0) {
-                                    lineStartIndex = 0;
-                                    break;
-                                }
+                            // Whitespace on both sides means arithmetic ('5 * 0') or a bare list
+                            // marker, never an emphasis delimiter (c347b53).
+                            if (isSpaceOrEdge(prevChar) && isSpaceOrEdge(nextChar)) {
+                                continue;
                             }
-                            const beforeAsterisk = line.substring(lineStartIndex, i);
-                            if (beforeAsterisk.trim() === '' && (nextChar === ' ' || nextChar === '\t')) {
+                            if (isWithinCompleteInlineCode(line, i)) {
                                 continue;
                             }
                             if (prevChar !== '*' && nextChar !== '*') {
                                 singleAsterisks++;
+                                lastSingleAsterisk = i;
                             }
                         }
                     }
                     if (singleAsterisks % 2 === 1) {
+                        // The dangling asterisk is the last counted one. If it cannot OPEN
+                        // emphasis (nothing or whitespace after it) it is an intraword or
+                        // trailing closer — '*foo*bar*' is literal, not half of '*foo*bar**'
+                        // (9f96409).
+                        if (isSpaceOrEdge(line[lastSingleAsterisk + 1] ?? '')) {
+                            return line;
+                        }
                         // Inline findFirstSingleAsterisk logic
                         let firstSingleAsteriskIndex = -1;
                         for (let i = 0; i < line.length; i++) {
                             if (line[i] === '*' && line[i - 1] !== '*' && line[i + 1] !== '*') {
                                 const prevChar = i > 0 ? line[i - 1] : '';
                                 const nextChar = i < line.length - 1 ? line[i + 1] : '';
+                                if (isSpaceOrEdge(prevChar) && isSpaceOrEdge(nextChar))
+                                    continue;
+                                if (isWithinCompleteInlineCode(line, i))
+                                    continue;
                                 if (/\w/.test(prevChar) && /\w/.test(nextChar))
                                     continue;
                                 if (/\w/.test(prevChar) && !/\s/.test(prevChar))
@@ -391,6 +421,8 @@ export class IncompleteMarkdownParser {
                                 continue;
                             if (isWithinMathBlock(line, i))
                                 continue;
+                            if (isWithinCompleteInlineCode(line, i))
+                                continue;
                             if (prevChar &&
                                 nextChar &&
                                 /[\p{L}\p{N}_]/u.test(prevChar) &&
@@ -410,7 +442,8 @@ export class IncompleteMarkdownParser {
                                 line[i - 1] !== '_' &&
                                 line[i + 1] !== '_' &&
                                 line[i - 1] !== '\\' &&
-                                !isWithinMathBlock(line, i)) {
+                                !isWithinMathBlock(line, i) &&
+                                !isWithinCompleteInlineCode(line, i)) {
                                 const prevChar = i > 0 ? line[i - 1] : '';
                                 const nextChar = i < line.length - 1 ? line[i + 1] : '';
                                 if (prevChar &&
@@ -450,11 +483,17 @@ export class IncompleteMarkdownParser {
                     }
                     if (singleTildes % 2 === 1) {
                         const lastTildeIndex = line.lastIndexOf('~');
-                        if (lastTildeIndex !== -1 && !isWithinMathBlock(line, lastTildeIndex)) {
+                        if (lastTildeIndex !== -1 &&
+                            !isWithinMathBlock(line, lastTildeIndex) &&
+                            !isWithinCompleteInlineCode(line, lastTildeIndex)) {
                             const endOfCellOrLine = findEndOfCellOrLineContaining(line, lastTildeIndex);
-                            // Only complete if there's content after the tilde
                             const contentAfterTilde = line.substring(lastTildeIndex + 1, endOfCellOrLine);
-                            if (contentAfterTilde.trim().length > 0) {
+                            // A subscript is '~text~' with no whitespace inside (same rule as the
+                            // lexer), and a digit before the tilde means a range like '20~25°C':
+                            // closing those would manufacture a subscript nobody typed (716a5f0).
+                            if (contentAfterTilde.length > 0 &&
+                                !/\s/.test(contentAfterTilde) &&
+                                !/\d/.test(line[lastTildeIndex - 1] ?? '')) {
                                 return line.substring(0, endOfCellOrLine) + '~' + line.substring(endOfCellOrLine);
                             }
                         }
@@ -580,6 +619,9 @@ export class IncompleteMarkdownParser {
                                 continue;
                             if (nextChar && /\d/.test(nextChar))
                                 continue;
+                            // A '$' shown as code ('`$var`') must not flip the parity (e50b0c4)
+                            if (isWithinCompleteInlineCode(line, i))
+                                continue;
                             singleDollars++;
                         }
                     }
@@ -593,7 +635,8 @@ export class IncompleteMarkdownParser {
                                     prevChar !== '$' &&
                                     nextChar !== '$' &&
                                     nextChar !== '' &&
-                                    !/\d/.test(nextChar)) {
+                                    !/\d/.test(nextChar) &&
+                                    !isWithinCompleteInlineCode(line, i)) {
                                     lastDollarIndex = i;
                                     break;
                                 }
@@ -866,6 +909,11 @@ export const parseIncompleteMarkdown = (text) => {
     return defaultParser.parse(text);
 };
 // Utility functions
+// Full test for the comparisonOperator plugin, whose `pattern` only gates it.
+const listItemComparison = /^(\s*(?:[-*+]|\d+[.)]) +)>(?==?\s*\$?\d)/;
+// The char accessors in the plugins return '' past either end of the line, so an
+// empty string here means "edge of line".
+const isSpaceOrEdge = (char) => !char || /\s/.test(char);
 const findEndOfCellOrLineContaining = (text, position) => {
     let endPos = position;
     while (endPos < text.length && text[endPos] !== '\n' && text[endPos] !== '|') {
@@ -873,6 +921,40 @@ const findEndOfCellOrLineContaining = (text, position) => {
     }
     return endPos;
 };
+// Scanned on demand, against the line as it stands now, and allocating nothing:
+// the completer runs over every changed block of every streamed chunk, so garbage
+// here surfaces as GC pauses in the stages around it.
+const isWithinCompleteInlineCode = (line, position) => {
+    let open = line.indexOf('`');
+    while (open !== -1 && open <= position) {
+        let openEnd = open;
+        while (line.charCodeAt(openEnd) === 96)
+            openEnd++;
+        const runLength = openEnd - open;
+        let closeStart = -1;
+        for (let j = openEnd; j < line.length; j++) {
+            if (line.charCodeAt(j) !== 96)
+                continue;
+            let closeEnd = j;
+            while (line.charCodeAt(closeEnd) === 96)
+                closeEnd++;
+            if (closeEnd - j === runLength) {
+                closeStart = j;
+                break;
+            }
+            j = closeEnd - 1;
+        }
+        // An unterminated run closes nothing, so neither it nor anything after it
+        // is code: completing emphasis inside it is what streaming needs.
+        if (closeStart === -1)
+            return false;
+        const spanEnd = closeStart + runLength;
+        if (position < spanEnd)
+            return true;
+        open = line.indexOf('`', spanEnd);
+    }
+    return false;
+};
 const isWithinMathBlock = (text, position) => {
     let inInlineMath = false;
     let inBlockMath = false;

package/dist/utils/save.js

@@ -1,5 +1,8 @@
 export const save = (filename, content, mimeType) => {
-    const blob = new Blob([content], { type: mimeType });
+    // Excel on Windows assumes the system codepage without a BOM, so accented
+    // and CJK text in a downloaded CSV opens as mojibake.
+    const body = mimeType.startsWith('text/csv') ? '\uFEFF' + content : content;
+    const blob = new Blob([body], { type: mimeType });
     const url = URL.createObjectURL(blob);
     const link = document.createElement('a');
     link.href = url;

package/dist/utils/url.js

@@ -25,6 +25,7 @@ export const isPathRelativeUrl = (url) => {
         return false;
     return url.startsWith('/');
 };
+const WILDCARD_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'tel:']);
 export const transformUrl = (url, allowedPrefixes, defaultOrigin) => {
     if (!url)
         return null;
@@ -61,8 +62,11 @@ export const transformUrl = (url, allowedPrefixes, defaultOrigin) => {
     }
     // Check for wildcard - allow all URLs
     if (allowedPrefixes.includes('*')) {
-        // Wildcard only allows http and https URLs
-        if (parsedUrl.protocol !== 'https:' && parsedUrl.protocol !== 'http:') {
+        // The wildcard allows the protocols a document can legitimately link to.
+        // javascript:, data: and vbscript: stay blocked - they execute in the
+        // page's origin. mailto:/tel: were missing, so the default ['*'] config
+        // rendered a [blocked] badge on every phone and email link.
+        if (!WILDCARD_PROTOCOLS.has(parsedUrl.protocol)) {
             return null;
         }
         const inputWasRelative = isPathRelativeUrl(url);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-streamdown",
-	"version": "3.1.2",
+	"version": "4.0.1",
 	"packageManager": "pnpm@10.32.1",
 	"repository": {
 		"type": "git",
@@ -22,7 +22,8 @@
 		"lint": "prettier --check .",
 		"test:ui": "vitest --ui",
 		"test:unit": "vitest",
-		"test": "npm run test:unit -- --run"
+		"test:browser": "vitest --run --project client",
+		"test": "npm run test:unit -- --run --project server"
 	},
 	"files": [
 		"dist",
@@ -94,13 +95,11 @@
 	},
 	"dependencies": {
 		"@floating-ui/dom": "^1.7.4",
-		"@shikijs/langs": "^3.17.1",
-		"@shikijs/themes": "^3.17.1",
+		"@tanstack/highlight": "^0.1.0",
 		"clsx": "^2.1.1",
 		"katex": "^0.16.22",
-		"marked": "^16.2.1",
+		"marked": "18.0.12",
 		"mermaid": "^11.15.0",
-		"shiki": "^3.13.0",
 		"tailwind-merge": "^3.3.1"
 	}
 }

package/dist/utils/bundledLanguages.d.ts

@@ -1,8 +0,0 @@
-export type LanguageInfo = {
-    id: string;
-    aliases?: string[];
-    import: () => Promise<any>;
-};
-export declare const bundledLanguagesInfo: LanguageInfo[];
-export declare function createLanguageSet(languages: LanguageInfo[]): Set<string>;
-export declare const supportedLanguages: Set<string>;