svelte-streamdown 3.1.2 → 4.0.1

package/dist/Elements/fallbacks/CodeFallback.svelte

@@ -11,6 +11,12 @@
 	} = $props();
 
 	const streamdown = useStreamdown();
+
+	// Same trim as Code.svelte/Mermaid.svelte: marked keeps the fence's trailing
+	// blank lines in `text`, so they render as empty lines and flicker in and out
+	// on nearly every streamed chunk. This is the default renderer, so it needs it
+	// too.
+	const code = $derived(token.text.replace(/\n+$/, ''));
 </script>
 
 <div
@@ -23,7 +29,7 @@
 	</div>
 	<div style="height: fit-content; width: 100%;" class={streamdown.theme.code.container}>
 		<pre class={streamdown.theme.code.pre}><code
-				>{#each token.text.split('\n') as line}<span class={streamdown.theme.code.line}
+				>{#each code.split('\n') as line}<span class={streamdown.theme.code.line}
 						><span style={streamdown.isMounted ? streamdown.animationTextStyle : ''}
 							>{line.trim().length > 0 ? line : '\u200B'}</span
 						></span

package/dist/Elements/fallbacks/MermaidFallback.svelte

@@ -11,6 +11,12 @@
 	} = $props();
 
 	const streamdown = useStreamdown();
+
+	// Same trim as Code.svelte/Mermaid.svelte: marked keeps the fence's trailing
+	// blank lines in `text`, so they render as empty lines and flicker in and out
+	// on nearly every streamed chunk. This is the default renderer, so it needs it
+	// too.
+	const chart = $derived(token.text.replace(/\n+$/, ''));
 </script>
 
 <div data-streamdown-mermaid={id}>
@@ -23,7 +29,7 @@
 		</div>
 		<div style="height: fit-content; width: 100%;" class={streamdown.theme.code.container}>
 			<pre class={streamdown.theme.code.pre}><code
-					>{#each token.text.split('\n') as line}<span class={streamdown.theme.code.line}
+					>{#each chart.split('\n') as line}<span class={streamdown.theme.code.line}
 							><span style={streamdown.isMounted ? streamdown.animationTextStyle : ''}
 								>{line.trim().length > 0 ? line : '\u200B'}</span
 							></span

package/dist/Streamdown.svelte

@@ -7,9 +7,9 @@
 	let {
 		content = '',
 		class: className,
-		shikiTheme,
-		shikiLanguages,
-		shikiThemes,
+		highlightTheme,
+		highlightLanguages,
+		highlightThemes,
 		parseIncompleteMarkdown,
 		defaultOrigin,
 		allowedLinkPrefixes = ['*'],
@@ -36,15 +36,12 @@
 		...snippets
 	}: StreamdownProps<Source> = $props();
 	import { useDarkMode } from './utils/darkMode.svelte.js';
+	import { resolveHighlightTheme } from './utils/highlightThemes.js';
 
 	const darkMode = useDarkMode();
 
-	const shikiThemedTheme = $derived(
-		shikiThemes
-			? Object.keys(shikiThemes)[0] || 'github-light'
-			: darkMode.current
-				? 'github-dark'
-				: 'github-light'
+	const resolvedHighlightTheme = $derived(
+		resolveHighlightTheme(highlightTheme, highlightThemes, darkMode.current)
 	);
 
 	const mermaidThemedTheme = $derived(
@@ -70,8 +67,8 @@
 		get allowedImagePrefixes() {
 			return allowedImagePrefixes;
 		},
-		get shikiTheme() {
-			return shikiTheme || shikiThemedTheme;
+		get highlightTheme() {
+			return resolvedHighlightTheme;
 		},
 		get snippets() {
 			return snippets;
@@ -99,11 +96,11 @@
 		get translations() {
 			return translations;
 		},
-		get shikiLanguages() {
-			return shikiLanguages;
+		get highlightLanguages() {
+			return highlightLanguages;
 		},
-		get shikiThemes() {
-			return shikiThemes;
+		get highlightThemes() {
+			return highlightThemes;
 		},
 		get sources() {
 			return sources;

package/dist/context.svelte.d.ts

@@ -2,11 +2,11 @@ import type { Component, Snippet } from 'svelte';
 import type { DeepPartialTheme, Theme } from './theme.js';
 import type { MermaidConfig } from 'mermaid';
 import type { KatexOptions } from 'katex';
-import type { LanguageInfo } from './utils/bundledLanguages.js';
-import type { ThemeRegistration } from 'shiki';
-export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'shikiTheme' | 'inlineCitationsMode'> {
+import type { HighlightTheme } from '@tanstack/highlight/theme';
+import type { LanguageDefinition } from '@tanstack/highlight';
+export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'highlightTheme' | 'inlineCitationsMode'> {
     snippets: Snippets;
-    shikiTheme: string;
+    highlightTheme: HighlightTheme;
     theme: Theme;
     controls: {
         code: boolean;
@@ -27,8 +27,9 @@ export declare class StreamdownContext<Source extends Record<string, any> = Reco
     isMounted: boolean;
     get animationTextStyle(): string | undefined;
     get animationBlockStyle(): string | undefined;
-    constructor(props: Omit<StreamdownProps, keyof Snippets | 'class'> & {
+    constructor(props: Omit<StreamdownProps, keyof Snippets | 'class' | 'highlightTheme'> & {
         snippets: Snippets<Source>;
+        highlightTheme: HighlightTheme;
     });
 }
 export declare const useStreamdown: () => StreamdownContext<Record<string, any>>;
@@ -108,9 +109,9 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
     theme?: DeepPartialTheme;
     baseTheme?: 'tailwind' | 'shadcn';
     mergeTheme?: boolean;
-    shikiTheme?: string;
-    shikiLanguages?: LanguageInfo[];
-    shikiThemes?: Record<string, ThemeRegistration>;
+    highlightTheme?: string;
+    highlightLanguages?: LanguageDefinition[];
+    highlightThemes?: Record<string, HighlightTheme>;
     mermaidConfig?: MermaidConfig;
     katexConfig?: KatexOptions | ((inline: boolean) => KatexOptions);
     translations?: {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { default as Streamdown } from './Streamdown.svelte';
 export { useStreamdown, type StreamdownProps } from './context.svelte.js';
 export { theme, shadcnTheme, mergeTheme, type Theme } from './theme.js';
-export { type Extension, type StreamdownToken, lex, parseBlocks } from './marked/index.js';
+export { type CodeToken, type Extension, type StreamdownToken, lex, parseBlocks } from './marked/index.js';
 export { parseIncompleteMarkdown, type Plugin, IncompleteMarkdownParser } from './utils/parse-incomplete-markdown.js';
-export { bundledLanguagesInfo, createLanguageSet, type LanguageInfo } from './utils/bundledLanguages.js';
+export { defineLanguage, type LanguageDefinition } from '@tanstack/highlight';
+export type { HighlightTheme } from '@tanstack/highlight/theme';

package/dist/index.js

@@ -3,4 +3,4 @@ export { useStreamdown } from './context.svelte.js';
 export { theme, shadcnTheme, mergeTheme } from './theme.js';
 export { lex, parseBlocks } from './marked/index.js';
 export { parseIncompleteMarkdown, IncompleteMarkdownParser } from './utils/parse-incomplete-markdown.js';
-export { bundledLanguagesInfo, createLanguageSet } from './utils/bundledLanguages.js';
+export { defineLanguage } from '@tanstack/highlight';

package/dist/marked/index.d.ts

@@ -23,7 +23,14 @@ export type Extension = {
     start?: TokenizerStartFunction;
     applyInBlockParsing?: boolean;
 };
-export type StreamdownToken = Exclude<MarkedToken, Tokens.List | Tokens.ListItem | Tokens.Table> | ListToken | ListItemToken | MathToken | AlertToken | FootnoteToken | SubSupToken | BrToken | HrToken | TableToken | THead | TBody | TFoot | THeadRow | TRow | TH | TD | DescriptionListToken | DescriptionToken | DescriptionDetailToken | DescriptionTermToken | AlignToken | CitationToken | MdxToken;
+/**
+ * A fenced code block. `lang` is the first word of the info string; everything
+ * after it is `meta` (`undefined` when there is none).
+ */
+export type CodeToken = Tokens.Code & {
+    meta?: string;
+};
+export type StreamdownToken = Exclude<MarkedToken, Tokens.List | Tokens.ListItem | Tokens.Table | Tokens.Code> | CodeToken | ListToken | ListItemToken | MathToken | AlertToken | FootnoteToken | SubSupToken | BrToken | HrToken | TableToken | THead | TBody | TFoot | THeadRow | TRow | TH | TD | DescriptionListToken | DescriptionToken | DescriptionDetailToken | DescriptionTermToken | AlignToken | CitationToken | MdxToken;
 export type { TableToken, THead, TBody, TFoot, THeadRow, TRow, TH, TD } from './marked-table.js';
 export declare const lex: (markdown: string, extensions?: Extension[]) => StreamdownToken[];
 /**
@@ -31,13 +38,25 @@ export declare const lex: (markdown: string, extensions?: Extension[]) => Stream
  * instance (or per simulated stream) and pass it on every call: append-only
  * content updates then re-lex only the last couple of blocks instead of the
  * whole document. Any non-append update falls back to a full parse.
+ *
+ * Everything here is sized so the append path costs O(live tail), never
+ * O(document): `offsets`/`keptBefore` are prefix sums so the seal point is an
+ * array lookup, and `blocks` is a persistent array whose tail is truncated and
+ * re-pushed instead of being rebuilt with a `filter` callback every chunk.
  */
 export type ParseBlocksCache = {
+    /** the content the cache describes (held by reference, never copied); '' = cold */
     content: string;
     /** every block token's raw (including space/footnote tokens) in document order */
     raws: string[];
     /** parallel to raws: whether the token is part of the rendered block list */
     keep: boolean[];
+    /** prefix sums: offsets[i] = start index of raws[i]; offsets[raws.length] = content.length */
+    offsets: number[];
+    /** prefix sums: keptBefore[i] = number of kept tokens among raws[0..i) */
+    keptBefore: number[];
+    /** persistent list of kept raws; only its tail is rewritten on append */
+    blocks: string[];
 };
 export declare const createParseBlocksCache: () => ParseBlocksCache;
 export declare const parseBlocks: (markdown: string, extensions?: Extension[], cache?: ParseBlocksCache) => string[];

package/dist/marked/index.js

@@ -1,4 +1,4 @@
-import { Lexer } from 'marked';
+import { Lexer, Tokenizer } from 'marked';
 import { markedAlert } from './marked-alert.js';
 import { markedFootnote } from './marked-footnotes.js';
 import { markedMath } from './marked-math.js';
@@ -39,9 +39,42 @@ const DEFAULT_BLOCK_EXTENSIONS = [
     markedAlign,
     markedMdx
 ];
+class StreamdownTokenizer extends Tokenizer {
+    /**
+     * marked keeps the whole fence info string in `lang`, so ```ts title="x" {1}
+     * highlighted as plaintext, labelled the header with the entire string, downloaded
+     * as `file.txt` and — worst — missed `token.lang === 'mermaid'` (upstream d4ec6c0).
+     * Splitting here rather than walking lex()'s output costs one search per code
+     * token instead of a per-block tree walk, and it also reaches fences nested in
+     * lists and blockquotes, which a pass over the top-level tokens would not.
+     */
+    fences(src) {
+        const token = super.fences(src);
+        if (token?.lang) {
+            const end = token.lang.search(/\s/);
+            if (end !== -1) {
+                token.meta = token.lang.slice(end + 1).trim() || undefined;
+                token.lang = token.lang.slice(0, end);
+            }
+        }
+        return token;
+    }
+    /**
+     * `~x~` is a subscript here, not GFM strikethrough (marked-subsup.ts). The old
+     * subscript rule shadowed single-tilde del by matching anything; now that it
+     * rejects whitespace, del would inherit exactly the sentences 716a5f0 is about
+     * (`20~25°C and 30~35°C` → del('~25°C and 30~')). Only `~~` opens a del.
+     */
+    del(src, maskedSrc, prevChar) {
+        if (src.charCodeAt(0) !== 126 /* ~ */ || src.charCodeAt(1) !== 126)
+            return;
+        return super.del(src, maskedSrc, prevChar);
+    }
+}
 const parseExtensions = (...extensions) => {
     const options = {
         gfm: true,
+        tokenizer: new StreamdownTokenizer(),
         extensions: {
             block: [],
             inline: [],
@@ -71,9 +104,12 @@ const parseExtensions = (...extensions) => {
     });
     return options;
 };
-// Options objects are stateless and reusable across Lexer instances; cache them
-// per user-extension array (props are referentially stable across chunks) so the
-// hot path skips rebuilding ~20 tokenizer registrations on every streamed chunk.
+// Options objects are reusable across Lexer instances; cache them per
+// user-extension array (props are referentially stable across chunks) so the hot
+// path skips rebuilding ~20 tokenizer registrations on every streamed chunk. The
+// cached object carries one shared Tokenizer whose `lexer` back-pointer marked
+// re-stamps per Lexer construction — safe only because lexing is synchronous and
+// never re-entrant across documents.
 const DEFAULT_LEX_OPTIONS = parseExtensions(...DEFAULT_LEX_EXTENSIONS);
 const DEFAULT_BLOCK_OPTIONS = parseExtensions(...DEFAULT_BLOCK_EXTENSIONS);
 const lexOptionsCache = new WeakMap();
@@ -106,21 +142,79 @@ export const lex = (markdown, extensions = []) => {
 export const createParseBlocksCache = () => ({
     content: '',
     raws: [],
-    keep: []
+    keep: [],
+    offsets: [0],
+    keptBefore: [0],
+    blocks: []
 });
 // Number of trailing rendered blocks that stay "live" (re-lexed every chunk).
 // 2 covers constructs that merge backward as they stream in — e.g. a paragraph
 // line becoming a table once its delimiter row arrives, or a setext heading.
 const SEAL_SLACK = 2;
-const blockTokensOf = (markdown, extensions) => new Lexer(getBlockOptions(extensions)).blockTokens(markdown, []);
+// Spot checks over the sealed prefix per append (see `appendable`). The sealed
+// region was compared byte-for-byte while it was live, so this only has to catch
+// a caller that swapped in a different, longer document.
+const SEAL_PROBES = 16;
+/**
+ * A Lexer used only to slice a document into top-level block raws.
+ *
+ * `Tokenizer.list()` recurses into every list item's text purely to decide
+ * whether the list is loose — `raw` is already final by then — and it marks that
+ * recursion by setting `state.top = false` first. `Tokenizer.blockquote()` also
+ * recurses, but its `raw` genuinely depends on the result (continuation lines are
+ * folded into a nested list/blockquote token), and it sets `state.top = true`.
+ * So dropping every nested call made with `top === false` removes the whole
+ * list-item subtree parse without changing a single raw.
+ */
+class SplitLexer extends Lexer {
+    blockTokens(src, tokens = [], lastParagraphClipped = false) {
+        if (!this.state.top) {
+            // Lexer.blockTokens() sets state.top = true on exit; the skip must too.
+            this.state.top = true;
+            return tokens;
+        }
+        return super.blockTokens(src, tokens, lastParagraphClipped);
+    }
+    /** Extensions (dl, table) tokenize cell/term text inline; raws never depend on it. */
+    inlineTokens(src, tokens = []) {
+        return tokens;
+    }
+}
+const blockTokensOf = (markdown, extensions) => new SplitLexer(getBlockOptions(extensions)).blockTokens(markdown, []);
+/**
+ * Is `markdown` an append to `cache.content`?
+ *
+ * The live region [offset, cache.content.length) is compared exactly — that is
+ * the only region whose segmentation can still change. The sealed prefix gets
+ * SEAL_PROBES sampled character comparisons instead of a full scan: a complete
+ * `markdown.startsWith(cache.content)` was 93% of parseBlocks' streaming cost
+ * (676 ms of 727 ms over a 100 KB / 5028-chunk stream) and is the single reason
+ * the append path was O(N) per chunk rather than O(tail).
+ *
+ * Note this compares source against source, not source against `raws`: marked's
+ * tokenizers normalize (e.g. the list tokenizer rewrites a trailing space as a
+ * newline), so raws are not always literal slices of the input.
+ */
+const appendable = (markdown, content, offset) => {
+    for (let i = offset; i < content.length; i++) {
+        if (markdown.charCodeAt(i) !== content.charCodeAt(i))
+            return false;
+    }
+    if (offset === 0)
+        return true;
+    const step = offset > SEAL_PROBES ? offset / SEAL_PROBES : 1;
+    for (let f = 0; f < offset; f += step) {
+        const i = f | 0;
+        if (markdown.charCodeAt(i) !== content.charCodeAt(i))
+            return false;
+    }
+    return markdown.charCodeAt(offset - 1) === content.charCodeAt(offset - 1);
+};
 export const parseBlocks = (markdown, extensions = [], cache) => {
-    if (cache &&
-        cache.content.length > 0 &&
-        markdown.length > cache.content.length &&
-        markdown.startsWith(cache.content)) {
+    if (cache && cache.content.length > 0 && markdown.length > cache.content.length) {
         // Append-only update: seal everything except the last SEAL_SLACK rendered
-        // blocks and re-lex only the tail. cache.raws concatenates exactly to
-        // cache.content (verified by length below), so summed lengths are offsets.
+        // blocks and re-lex only the tail. offsets[] are prefix sums over raws, so
+        // the seal point costs one array read instead of a running sum.
         let cut = cache.raws.length;
         let liveBlocks = 0;
         while (cut > 0 && liveBlocks < SEAL_SLACK) {
@@ -128,45 +222,72 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
             if (cache.keep[cut])
                 liveBlocks++;
         }
-        let offset = 0;
-        for (let i = 0; i < cut; i++)
-            offset += cache.raws[i].length;
-        const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
-        let tailLength = 0;
-        for (const token of tailTokens)
-            tailLength += token.raw.length;
-        // Contiguity guard: if the lexer normalized the tail (so raws no longer
-        // reconstruct the input), the offsets cannot be trusted — full reparse.
-        if (offset + tailLength === markdown.length) {
-            cache.raws.length = cut;
-            cache.keep.length = cut;
-            for (const token of tailTokens) {
-                cache.raws.push(token.raw);
-                cache.keep.push(token.type !== 'space' && token.type !== 'footnote');
+        const offset = cache.offsets[cut];
+        if (appendable(markdown, cache.content, offset)) {
+            const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
+            let tailLength = 0;
+            for (const token of tailTokens)
+                tailLength += token.raw.length;
+            // Contiguity guard: if the lexer normalized the tail (so raws no longer
+            // reconstruct the input), the offsets cannot be trusted — full reparse.
+            if (offset + tailLength === markdown.length) {
+                const keptAtCut = cache.keptBefore[cut];
+                cache.raws.length = cut;
+                cache.keep.length = cut;
+                cache.offsets.length = cut + 1;
+                cache.keptBefore.length = cut + 1;
+                cache.blocks.length = keptAtCut;
+                let pos = offset;
+                let kept = keptAtCut;
+                for (const token of tailTokens) {
+                    const raw = token.raw;
+                    const keep = token.type !== 'space' && token.type !== 'footnote';
+                    cache.raws.push(raw);
+                    cache.keep.push(keep);
+                    pos += raw.length;
+                    cache.offsets.push(pos);
+                    if (keep) {
+                        cache.blocks.push(raw);
+                        kept++;
+                    }
+                    cache.keptBefore.push(kept);
+                }
+                cache.content = markdown;
+                // Copy out: callers (Svelte `$derived`, the perf harness) diff block
+                // lists by identity, so handing back the persistent array would read as
+                // "nothing changed". slice() is a memcpy with no per-element callback.
+                return cache.blocks.slice();
             }
-            cache.content = markdown;
-            return cache.raws.filter((_, i) => cache.keep[i]);
         }
     }
     // Full parse (first call, non-append update, or contiguity fallback).
     const tokens = blockTokensOf(markdown, extensions);
-    const blocks = [];
     if (cache) {
-        cache.raws = [];
-        cache.keep = [];
-        let total = 0;
+        cache.raws.length = 0;
+        cache.keep.length = 0;
+        cache.offsets.length = 1;
+        cache.keptBefore.length = 1;
+        cache.blocks.length = 0;
+        let pos = 0;
+        let kept = 0;
         for (const token of tokens) {
+            const raw = token.raw;
             const keep = token.type !== 'space' && token.type !== 'footnote';
-            cache.raws.push(token.raw);
+            cache.raws.push(raw);
             cache.keep.push(keep);
-            total += token.raw.length;
-            if (keep)
-                blocks.push(token.raw);
+            pos += raw.length;
+            cache.offsets.push(pos);
+            if (keep) {
+                cache.blocks.push(raw);
+                kept++;
+            }
+            cache.keptBefore.push(kept);
         }
         // Only trust the cache for future appends if raws reconstruct the input.
-        cache.content = total === markdown.length ? markdown : '';
-        return blocks;
+        cache.content = pos === markdown.length ? markdown : '';
+        return cache.blocks.slice();
     }
+    const blocks = [];
     for (const token of tokens) {
         if (token.type !== 'space' && token.type !== 'footnote')
             blocks.push(token.raw);

package/dist/marked/marked-br.js

@@ -2,6 +2,12 @@ export const markedBr = {
     name: 'br',
     level: 'inline',
     tokenizer(src) {
+        // marked dispatches every inline extension at every scan position; `start`
+        // only clips the text rule, it does not gate the tokenizer. This rule is
+        // anchored on a single literal character, so one charCodeAt rejects the
+        // ~3.6k non-matching dispatches per 100 KB before the regex engine runs.
+        if (src.charCodeAt(0) !== 60 /* < */)
+            return undefined;
         // Match HTML <br> tags (with or without closing slash, case insensitive)
         const match = src.match(/^<br\s*\/?>/i);
         if (match) {

package/dist/marked/marked-citations.js

@@ -6,6 +6,12 @@ export const markedCitations = {
         return i === -1 ? -1 : i;
     },
     tokenizer(src) {
+        // marked dispatches every inline extension at every scan position; `start`
+        // only clips the text rule, it does not gate the tokenizer. This rule is
+        // anchored on a single literal character, so one charCodeAt rejects the
+        // ~3.6k non-matching dispatches per 100 KB before the regex engine runs.
+        if (src.charCodeAt(0) !== 91 /* [ */)
+            return;
         // Match inline citations like [1], [ref], [1] [2], [ref] [ref2], etc.
         // Requires non-empty bracket contents and spaces between adjacent citation brackets
         const match = src.match(/^\[[^\][]+\](?:\s+\[[^\][]+\])*/);

package/dist/marked/marked-footnotes.js

@@ -1,8 +1,12 @@
 import {} from './index.js';
 import { StreamdownContext } from '../context.svelte.js';
 import { getContext } from 'svelte';
-const footnoteRegex = /^\[\^([^\]\n]+)\]:(?:[ \t]+|\n|$)([^\n]*(?:\n(?:[ \t]+[^\n]*)?)*)/;
-const footnoteRefRegex = /^\[\^([^\]\n]+)\]/;
+// Footnote identifiers are word characters, `-` and `:` only. `[^\]\n]+` turned
+// every regex character class written in prose (`[^\s]`, `[^,]`) into an empty
+// footnote marker (upstream 9f72224). `:` is kept for the completer's
+// `[^streamdown:footnote]` sentinel, which FootnoteRef.svelte renders as nothing.
+const footnoteRegex = /^\[\^([\w:-]{1,200})\]:(?:[ \t]+|\n|$)([^\n]*(?:\n(?:[ \t]+[^\n]*)?)*)/;
+const footnoteRefRegex = /^\[\^([\w:-]{1,200})\]/;
 const footNoteLastLineRegex = /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/;
 const safeGetContext = () => {
     try {
@@ -34,9 +38,14 @@ export function markedFootnote() {
             name: 'footnote',
             level: 'block',
             tokenizer(src) {
-                const maps = ensureMaps(this);
+                // Match FIRST. ensureMaps() calls Svelte's getContext(), which throws
+                // (and is caught) whenever tokenizing happens outside component init —
+                // 3.3 us per call. Running it before the regex charged that to every
+                // block token in the document: 8.3 ms of the 13.0 ms it took to split a
+                // 100 KB document into blocks.
                 const match = footnoteRegex.exec(src);
                 if (match) {
+                    const maps = ensureMaps(this);
                     const [raw, label, text = ''] = match;
                     let content = text.split('\n').reduce((acc, curr) => {
                         return acc + '\n' + curr.replace(/^[ \t]+/, '');
@@ -66,9 +75,14 @@ export function markedFootnote() {
             name: 'footnoteRef',
             level: 'inline',
             tokenizer(src) {
-                const maps = ensureMaps(this);
+                // Same ordering rule as the block tokenizer above: this one is an inline
+                // extension, so it is dispatched at every inline scan position — so it also
+                // gets a single-character guard before the regex.
+                if (src.charCodeAt(0) !== 91 /* [ */)
+                    return;
                 const match = footnoteRefRegex.exec(src);
                 if (match) {
+                    const maps = ensureMaps(this);
                     const [raw, label] = match;
                     const footnote = maps.footnotes.get(label);
                     const token = {

package/dist/marked/marked-math.js

@@ -20,6 +20,8 @@ export const markedMath = [
         name: 'math',
         level: 'block',
         tokenizer(src) {
+            if (src.charCodeAt(0) !== 36 /* $ */)
+                return;
             const match = src.match(blockRule);
             if (match) {
                 // match[2] is multiline format, match[3] is single-line format
@@ -67,6 +69,9 @@ export const markedMath = [
             }
         },
         tokenizer(src) {
+            // inlineRule is anchored on `$`; skip the regex otherwise (see marked-br.ts).
+            if (src.charCodeAt(0) !== 36 /* $ */)
+                return;
             const match = src.match(inlineRule);
             if (match) {
                 const content = match[2];

package/dist/marked/marked-subsup.js

@@ -1,5 +1,8 @@
-const subRule = /^~([^~\s](?:[^~]*[^~\s])?)~/; // ~text~
-const supRule = /^\^([^\^\s](?:[^\^]*[^\^\s])?)\^/; // ^text^
+// A sub/superscript is a single run, never a phrase: no whitespace anywhere in
+// it. The old rules only forbade whitespace at the edges, so `20~25°C and 30~35°C`
+// subscripted half the sentence (upstream 716a5f0).
+const subRule = /^~([^~\s]+)~/; // ~text~
+const supRule = /^\^([^\^\s]+)\^/; // ^text^
 export const markedSub = {
     name: 'sub',
     level: 'inline',
@@ -7,7 +10,23 @@ export const markedSub = {
         const i = src.indexOf('~');
         return i === -1 ? undefined : i;
     },
-    tokenizer(src) {
+    tokenizer(src, tokens) {
+        // marked dispatches every inline extension at every scan position; `start`
+        // only clips the text rule, it does not gate the tokenizer. This rule is
+        // anchored on a single literal character, so one charCodeAt rejects the
+        // ~3.6k non-matching dispatches per 100 KB before the regex engine runs.
+        if (src.charCodeAt(0) !== 126 /* ~ */)
+            return;
+        // A digit right before the opening `~` means a numeric range (`20~25°C`),
+        // not a subscript base — chemistry and indices always have a letter or a
+        // closing bracket there (`H~2~O`, `x~i+1~`). `src` starts at the marker, so
+        // the preceding character is the last one of the previous inline token.
+        const prevRaw = tokens[tokens.length - 1]?.raw;
+        if (prevRaw) {
+            const code = prevRaw.charCodeAt(prevRaw.length - 1);
+            if (code >= 48 && code <= 57)
+                return;
+        }
         const match = src.match(subRule);
         if (match) {
             return {
@@ -27,6 +46,8 @@ export const markedSup = {
         return i === -1 ? undefined : i;
     },
     tokenizer(src) {
+        if (src.charCodeAt(0) !== 94 /* ^ */)
+            return;
         const match = src.match(supRule);
         if (match) {
             return {

package/dist/marked/marked-table.js

@@ -376,6 +376,19 @@ function processRows(headerRows, bodyRows, alignment, colCount, lexer, maxColspa
     }
     return tokens;
 }
+// Hoisted: this was `new RegExp(...)` inside the tokenizer, so a ~1 KB pattern was
+// concatenated and a RegExp constructed on every block-tokenizer dispatch — 3.3 ms
+// of the 13.0 ms it took to split a 100 KB document into blocks.
+const TABLE_WITH_ALIGN = new RegExp('^' +
+    '([^\\n ].*\\|.*\\n(?: *[^\\s].*\\n)*?)' + // Header
+    ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' + // Header Align
+    '(?:\\n((?:(?! *\\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})' + // Body Cells
+    '(?:\\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\\n]| {0,3}(?:`{3,}' +
+    '(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n| {0,3}(?:[*+-]|1[.)]) |' +
+    '<\\/?(?:address|article|aside|base|basefont|blockquote|body|' +
+    'caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\\n|\\/?>)|<(?:script|pre|style|textarea|!--)).*(?:\\n|$))*)\\n*|$)');
+// Tables written without a header alignment row (`|a|b|` rows only).
+const TABLE_NO_ALIGN = /^(\|.*\|(?:\n\|.*\|)*)/;
 const { detectFooter, maxColspan } = DEFAULT_OPTIONS;
 // Adds support for extended tables in marked with row spanning, column spanning,
 // multi-row headers, and column alignment
@@ -395,21 +408,11 @@ export const markedTable = {
     },
     tokenizer(src) {
         // Try to match table with header and alignment first
-        let regex = new RegExp('^' +
-            '([^\\n ].*\\|.*\\n(?: *[^\\s].*\\n)*?)' + // Header
-            ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' + // Header Align
-            '(?:\\n((?:(?! *\\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})' + // Body Cells
-            '(?:\\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\\n]| {0,3}(?:`{3,}' +
-            '(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n| {0,3}(?:[*+-]|1[.)]) |' +
-            '<\\/?(?:address|article|aside|base|basefont|blockquote|body|' +
-            'caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\\n|\\/?>)|<(?:script|pre|style|textarea|!--)).*(?:\\n|$))*)\\n*|$)');
-        let cap = regex.exec(src);
+        let cap = TABLE_WITH_ALIGN.exec(src);
         let hasHeaderAlignment = true;
         // If no match with header alignment, try table without header alignment
         if (!cap) {
-            // Simple regex for tables without header alignment
-            regex = /^(\|.*\|(?:\n\|.*\|)*)/;
-            cap = regex.exec(src);
+            cap = TABLE_NO_ALIGN.exec(src);
             hasHeaderAlignment = false;
         }
         if (!cap)