svelte-streamdown 4.1.0 → 4.2.0

package/dist/marked/index.js

@@ -10,13 +10,14 @@ import { markedTable } from './marked-table.js';
 import { markedDl } from './marked-dl.js';
 import { markedAlign } from './marked-align.js';
 import { markedCitations } from './marked-citations.js';
-import { markedMdx } from './marked-mdx.js';
-// Default plugin sets, in registration order. Hoisted so the options object
-// (and the regexes/closures inside each plugin) is built once, not per chunk.
-// The tokenizers are stateless at creation time — per-document state lives on
-// the Lexer instance (e.g. footnotes maps, reference-link defs), so a fresh
-// Lexer per call keeps documents isolated while the options are shared.
-const DEFAULT_LEX_EXTENSIONS = [
+import { markedMdx, DEFAULT_TAGS } from './marked-mdx.js';
+// Default plugin sets, in registration order. Built behind the options cache
+// below, so the options object (and the regexes/closures inside each plugin) is
+// built once per allowlist, not per chunk. The tokenizers are stateless at
+// creation time — per-document state lives on the Lexer instance (e.g. footnotes
+// maps, reference-link defs), so a fresh Lexer per call keeps documents isolated
+// while the options are shared.
+const defaultLexExtensions = (tags) => [
     markedHr,
     markedTable,
     ...markedFootnote(),
@@ -29,15 +30,15 @@ const DEFAULT_LEX_EXTENSIONS = [
     markedDl,
     markedAlign,
     markedCitations,
-    markedMdx
+    markedMdx(tags)
 ];
-const DEFAULT_BLOCK_EXTENSIONS = [
+const defaultBlockExtensions = (tags) => [
     markedHr,
     ...markedFootnote(),
     markedDl,
     markedTable,
     markedAlign,
-    markedMdx
+    markedMdx(tags)
 ];
 class StreamdownTokenizer extends Tokenizer {
     /**
@@ -104,38 +105,25 @@ const parseExtensions = (...extensions) => {
     });
     return options;
 };
-// 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();
-const blockOptionsCache = new WeakMap();
-const getLexOptions = (extensions) => {
-    if (extensions.length === 0)
-        return DEFAULT_LEX_OPTIONS;
-    let options = lexOptionsCache.get(extensions);
-    if (!options) {
-        options = parseExtensions(...DEFAULT_LEX_EXTENSIONS, ...extensions);
-        lexOptionsCache.set(extensions, options);
-    }
+// Stand-in key for "no user extensions" so both cache levels stay WeakMaps —
+// the `extensions = []` default allocates a fresh array on every call.
+const NO_EXTENSIONS = [];
+const cached = (cache, tags, extensions, build) => {
+    let byExtensions = cache.get(tags);
+    if (!byExtensions)
+        cache.set(tags, (byExtensions = new WeakMap()));
+    const key = extensions.length === 0 ? NO_EXTENSIONS : extensions;
+    let options = byExtensions.get(key);
+    if (!options)
+        byExtensions.set(key, (options = build()));
     return options;
 };
-const getBlockOptions = (extensions) => {
-    if (extensions.length === 0)
-        return DEFAULT_BLOCK_OPTIONS;
-    let options = blockOptionsCache.get(extensions);
-    if (!options) {
-        options = parseExtensions(...DEFAULT_BLOCK_EXTENSIONS, ...extensions.filter(({ level, applyInBlockParsing }) => level === 'block' && applyInBlockParsing));
-        blockOptionsCache.set(extensions, options);
-    }
-    return options;
-};
-export const lex = (markdown, extensions = []) => {
-    return new Lexer(getLexOptions(extensions))
+const lexOptionsCache = new WeakMap();
+const blockOptionsCache = new WeakMap();
+const getLexOptions = (extensions, tags) => cached(lexOptionsCache, tags, extensions, () => parseExtensions(...defaultLexExtensions(tags), ...extensions));
+const getBlockOptions = (extensions, tags) => cached(blockOptionsCache, tags, extensions, () => parseExtensions(...defaultBlockExtensions(tags), ...extensions.filter(({ level, applyInBlockParsing }) => level === 'block' && applyInBlockParsing)));
+export const lex = (markdown, extensions = [], tags = DEFAULT_TAGS) => {
+    return new Lexer(getLexOptions(extensions, tags))
         .lex(markdown)
         .filter((token) => token.type !== 'space' && token.type !== 'footnote');
 };
@@ -145,7 +133,8 @@ export const createParseBlocksCache = () => ({
     keep: [],
     offsets: [0],
     keptBefore: [0],
-    blocks: []
+    blocks: [],
+    lastUpdate: 'first'
 });
 // 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
@@ -181,7 +170,7 @@ class SplitLexer extends Lexer {
         return tokens;
     }
 }
-const blockTokensOf = (markdown, extensions) => new SplitLexer(getBlockOptions(extensions)).blockTokens(markdown, []);
+const blockTokensOf = (markdown, extensions, tags) => new SplitLexer(getBlockOptions(extensions, tags)).blockTokens(markdown, []);
 /**
  * Is `markdown` an append to `cache.content`?
  *
@@ -225,7 +214,23 @@ const appendable = (markdown, cache, cut, offset) => {
     }
     return markdown.charCodeAt(offset - 1) === content.charCodeAt(offset - 1);
 };
-export const parseBlocks = (markdown, extensions = [], cache) => {
+// An append this large in a single update is a paste or a "show all", not a
+// streamed chunk. Real streams arrive in tens of characters, and even a client
+// that batches renders to one frame at ~1000 tokens/s adds a few hundred; the
+// harm — thousands of spans starting a CSS animation in the same frame — only
+// begins well past this. ponytail: heuristic; a prop if anyone needs to tune it.
+const BULK_APPEND_CHARS = 2048;
+const updateKind = (isAppend, previousLength, length) => {
+    if (!isAppend)
+        return previousLength === 0 ? 'first' : 'bulk';
+    return length - previousLength > BULK_APPEND_CHARS ? 'bulk' : 'stream';
+};
+export const parseBlocks = (markdown, extensions = [], cache, tags = DEFAULT_TAGS) => {
+    // Whether this call extends the content the cache already described — decided
+    // by the same probe the fast path uses, so the contiguity fallback below still
+    // counts as an append for the animation's purposes.
+    let isAppend = false;
+    const previousLength = cache?.content.length ?? 0;
     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. offsets[] are prefix sums over raws, so
@@ -239,7 +244,8 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
         }
         const offset = cache.offsets[cut];
         if (appendable(markdown, cache, cut, offset)) {
-            const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
+            isAppend = true;
+            const tailTokens = blockTokensOf(markdown.slice(offset), extensions, tags);
             let tailLength = 0;
             for (const token of tailTokens)
                 tailLength += token.raw.length;
@@ -268,6 +274,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
                     cache.keptBefore.push(kept);
                 }
                 cache.content = markdown;
+                cache.lastUpdate = updateKind(isAppend, previousLength, markdown.length);
                 // 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.
@@ -276,7 +283,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
         }
     }
     // Full parse (first call, non-append update, or contiguity fallback).
-    const tokens = blockTokensOf(markdown, extensions);
+    const tokens = blockTokensOf(markdown, extensions, tags);
     if (cache) {
         cache.raws.length = 0;
         cache.keep.length = 0;
@@ -298,6 +305,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
             }
             cache.keptBefore.push(kept);
         }
+        cache.lastUpdate = updateKind(isAppend, previousLength, markdown.length);
         // Only trust the cache for future appends if raws reconstruct the input.
         cache.content = pos === markdown.length ? markdown : '';
         return cache.blocks.slice();
@@ -309,3 +317,4 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
     }
     return blocks;
 };
+export { compileTags, DEFAULT_TAGS } from './marked-mdx.js';

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

@@ -9,4 +9,30 @@ export type MdxToken = {
     tokens?: Token[];
     text?: string;
 };
-export declare const markedMdx: Extension;
+/**
+ * The tag vocabulary the mdx tokenizer and the streaming completer share,
+ * compiled once per allowlist (upstream fb9f97c/b392fbe). PascalCase is always
+ * in it; lowercase/hyphenated names only ever come from `customTags` /
+ * `mdxComponents`, so this can never swallow a real HTML tag the way a blanket
+ * `/^<([a-zA-Z][\w-]*)/` would.
+ */
+export type TagMatchers = {
+    /** `<Tag …/>` */
+    selfClosing: RegExp;
+    /** `<Tag …>` */
+    openTag: RegExp;
+    /** `</Tag>` */
+    closeTag: RegExp;
+    /** `<Tag …>…</Tag>`, both ends on one line */
+    complete: RegExp;
+    /** a bare allowed tag name, anchored */
+    name: RegExp;
+    /** the non-PascalCase names, kept as strings so a half-typed one can be prefix-matched */
+    names: string[];
+    /** tags whose children are emitted as one literal text token */
+    literal: Set<string>;
+};
+export declare const compileTags: (customTags?: string[], literalTagContent?: string[]) => TagMatchers;
+/** PascalCase only — what every call that passes no allowlist gets. */
+export declare const DEFAULT_TAGS: TagMatchers;
+export declare const markedMdx: (tags?: TagMatchers) => Extension;

package/dist/marked/marked-mdx.js

@@ -1,4 +1,26 @@
 import { Lexer } from 'marked';
+const escapeName = (name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// Attribute names take hyphens (`data-id`), not just word characters.
+const ATTRS = '((?:\\s+[\\w-]+=(?:"[^"]*"|{[^}]*}))*)';
+export const compileTags = (customTags, literalTagContent) => {
+    // A tag whose content is literal is a custom tag by definition: listing it
+    // once in `literalTagContent` must be enough, without repeating it in
+    // `customTags`.
+    const allowed = [...new Set([...(customTags ?? []), ...(literalTagContent ?? [])])];
+    const names = ['[A-Z][a-zA-Z0-9]*', ...allowed.map(escapeName)].join('|');
+    const tag = `(${names})`;
+    return {
+        selfClosing: new RegExp(`^<${tag}${ATTRS}\\s*/>`),
+        openTag: new RegExp(`^<${tag}${ATTRS}\\s*>`),
+        closeTag: new RegExp(`^</${tag}>`),
+        complete: new RegExp(`^<${tag}${ATTRS}\\s*>.*?</\\1>`),
+        name: new RegExp(`^(?:${names})$`),
+        names: allowed,
+        literal: new Set(literalTagContent ?? [])
+    };
+};
+/** PascalCase only — what every call that passes no allowlist gets. */
+export const DEFAULT_TAGS = compileTags();
 const defaultLexer = new Lexer({ gfm: true });
 const defaultTokenizer = defaultLexer.options.tokenizer;
 /**
@@ -8,7 +30,7 @@ const defaultTokenizer = defaultLexer.options.tokenizer;
 function parseAttributes(attributeString) {
     const attributes = {};
     // Pattern: attr="value" or attr={value}
-    const attrPattern = /(\w+)=(?:"([^"]*)"|{([^}]*)})/g;
+    const attrPattern = /([\w-]+)=(?:"([^"]*)"|{([^}]*)})/g;
     let match;
     while ((match = attrPattern.exec(attributeString)) !== null) {
         const [, name, stringValue, expressionValue] = match;
@@ -38,16 +60,17 @@ function parseAttributes(attributeString) {
     }
     return attributes;
 }
-export const markedMdx = {
+export const markedMdx = (tags = DEFAULT_TAGS) => ({
     name: 'mdx',
     level: 'block',
     applyInBlockParsing: true,
     tokenizer(src) {
-        // Match MDX component tags (must start with capital letter)
+        // Match a tag from the allowlist (PascalCase plus anything `customTags` /
+        // `mdxComponents` added).
         // Self-closing: <Component attr="value" />
         // With children: <Component attr="value">content</Component>
         // First try self-closing tag
-        const selfClosingMatch = src.match(/^<([A-Z][a-zA-Z0-9]*)((?:\s+\w+=(?:"[^"]*"|{[^}]*}))*)\s*\/>/);
+        const selfClosingMatch = src.match(tags.selfClosing);
         if (selfClosingMatch) {
             const [raw, tagName, attributeString] = selfClosingMatch;
             const attributes = parseAttributes(attributeString);
@@ -60,7 +83,7 @@ export const markedMdx = {
             };
         }
         // Try paired tag with children
-        const openTagMatch = src.match(/^<([A-Z][a-zA-Z0-9]*)((?:\s+\w+=(?:"[^"]*"|{[^}]*}))*)\s*>/);
+        const openTagMatch = src.match(tags.openTag);
         if (openTagMatch) {
             const [openTag, tagName, attributeString] = openTagMatch;
             const attributes = parseAttributes(attributeString);
@@ -106,8 +129,14 @@ export const markedMdx = {
                 const contentStart = openTag.length;
                 const content = src.substring(contentStart, closingIndex);
                 const raw = src.substring(0, closingIndex + closingTag.length);
-                // Parse children as markdown
-                const tokens = content.trim() ? this.lexer.blockTokens(content.trim(), []) : [];
+                // Parse children as markdown — unless the tag is in `literalTagContent`,
+                // where the inner text is data, not Markdown (upstream b392fbe): one
+                // text token, nothing escaped, `**` and `_` left alone.
+                const tokens = tags.literal.has(tagName)
+                    ? [{ type: 'text', raw: content, text: content }]
+                    : content.trim()
+                        ? this.lexer.blockTokens(content.trim(), [])
+                        : [];
                 return {
                     type: 'mdx',
                     raw,
@@ -121,4 +150,4 @@ export const markedMdx = {
         }
         return undefined;
     }
-};
+});

package/dist/theme.d.ts

@@ -44,6 +44,7 @@ export declare const theme: {
         language: string;
         pre: string;
         line: string;
+        lineNumber: string;
     };
     codespan: {
         base: string;
@@ -68,6 +69,7 @@ export declare const theme: {
     table: {
         base: string;
         table: string;
+        expanded: string;
     };
     thead: {
         base: string;
@@ -196,6 +198,7 @@ export declare const shadcnTheme: {
         language: string;
         pre: string;
         line: string;
+        lineNumber: string;
     };
     codespan: {
         base: string;
@@ -220,6 +223,7 @@ export declare const shadcnTheme: {
     table: {
         base: string;
         table: string;
+        expanded: string;
     };
     thead: {
         base: string;
@@ -353,6 +357,7 @@ export declare const mergeTheme: (customTheme?: DeepPartialTheme, baseTheme?: "t
         language: string;
         pre: string;
         line: string;
+        lineNumber: string;
     };
     codespan: {
         base: string;
@@ -377,6 +382,7 @@ export declare const mergeTheme: (customTheme?: DeepPartialTheme, baseTheme?: "t
     table: {
         base: string;
         table: string;
+        expanded: string;
     };
     thead: {
         base: string;

package/dist/theme.js

@@ -44,7 +44,10 @@ export const theme = {
         buttons: 'flex items-center gap-2',
         language: 'ml-1 font-mono lowercase',
         pre: 'overflow-x-auto font-mono p-0 bg-gray-100/40',
-        line: 'block'
+        line: 'block',
+        // Gutter appearance only; the counter itself is a global rule in
+        // Streamdown.svelte (see the comment there) so numbers work without Tailwind.
+        lineNumber: 'before:inline-block before:w-8 before:pr-3 before:text-right before:text-gray-400 before:select-none'
     },
     codespan: {
         base: 'bg-gray-100 rounded px-1.5 py-0.5 font-mono text-[0.9em]'
@@ -68,7 +71,10 @@ export const theme = {
     },
     table: {
         base: 'overflow-x-auto max-w-full my-4 border border-gray-200 rounded-lg',
-        table: 'w-full border-collapse min-w-full'
+        table: 'w-full border-collapse min-w-full',
+        // Added to `base` while fullscreen; the fixed positioning itself comes from
+        // the global [data-expanded='true'] rule.
+        expanded: 'overflow-auto bg-white p-2 pt-10 shadow-2xl'
     },
     thead: {
         base: 'bg-gray-200/80'
@@ -196,7 +202,8 @@ export const shadcnTheme = {
         buttons: 'flex items-center gap-2',
         language: 'ml-1 font-mono lowercase',
         pre: 'overflow-x-auto font-mono p-0 bg-muted/40',
-        line: 'block '
+        line: 'block ',
+        lineNumber: 'before:inline-block before:w-8 before:pr-3 before:text-right before:text-muted-foreground before:select-none'
     },
     codespan: {
         base: 'bg-muted rounded px-1.5 py-0.5 font-mono text-foreground text-[0.9em]'
@@ -220,7 +227,8 @@ export const shadcnTheme = {
     },
     table: {
         base: 'overflow-x-auto max-w-full my-4 rounded-lg border border-border',
-        table: 'w-full border-collapse min-w-full'
+        table: 'w-full border-collapse min-w-full',
+        expanded: 'overflow-auto bg-background p-2 pt-10 shadow-2xl'
     },
     thead: {
         base: 'bg-muted/80'

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

@@ -0,0 +1,21 @@
+/**
+ * The fullscreen half of the mermaid expand behaviour (Mermaid.svelte:264-267)
+ * without panzoom's `expand()`, which is entangled with `zoomToFit` and a FLIP
+ * animation a table has no use for: state, Escape and focus only. The
+ * `position: fixed` comes from the global `[data-expanded='true']` rule in
+ * Streamdown.svelte.
+ *
+ * The flag lives in the caller (so the markup can drive `role`/`aria-*`/the
+ * expanded class from it); this only drives it.
+ *
+ * // ponytail: no open/close animation. Upgrade path: measure the target rect
+ * // either side of `set()` and run the same first/last invert panzoom does,
+ * // once that block is untangled from the zoom state it reads today.
+ */
+export declare const useExpand: (opts: {
+    expanded: boolean;
+    getTarget: () => HTMLElement | null | undefined;
+}) => {
+    readonly expanded: boolean;
+    toggle: (from?: HTMLElement | null) => void;
+};

package/dist/utils/expand.svelte.js

@@ -0,0 +1,46 @@
+import { useKeyDown } from './useKeyDown.svelte.js';
+/**
+ * The fullscreen half of the mermaid expand behaviour (Mermaid.svelte:264-267)
+ * without panzoom's `expand()`, which is entangled with `zoomToFit` and a FLIP
+ * animation a table has no use for: state, Escape and focus only. The
+ * `position: fixed` comes from the global `[data-expanded='true']` rule in
+ * Streamdown.svelte.
+ *
+ * The flag lives in the caller (so the markup can drive `role`/`aria-*`/the
+ * expanded class from it); this only drives it.
+ *
+ * // ponytail: no open/close animation. Upgrade path: measure the target rect
+ * // either side of `set()` and run the same first/last invert panzoom does,
+ * // once that block is untangled from the zoom state it reads today.
+ */
+export const useExpand = (opts) => {
+    // The control that opened the overlay, so focus can return to it on close.
+    let trigger = null;
+    const set = (next) => {
+        const target = opts.getTarget();
+        opts.expanded = next;
+        if (target)
+            target.dataset.expanded = String(next);
+        if (next)
+            target?.focus();
+        else
+            trigger?.focus();
+    };
+    useKeyDown({
+        keys: ['Escape'],
+        get isActive() {
+            return opts.expanded;
+        },
+        callback: () => set(false)
+    });
+    return {
+        get expanded() {
+            return opts.expanded;
+        },
+        toggle: (from) => {
+            if (!opts.expanded)
+                trigger = from ?? null;
+            set(!opts.expanded);
+        }
+    };
+};

package/dist/utils/fence.d.ts

@@ -1,7 +1,12 @@
-/** An open code fence: the character it was opened with, and its run length. */
+/**
+ * An open code fence: the character it was opened with, its run length, and
+ * the prefix the opener sat behind (indentation, blockquote markers, a list
+ * marker). The prefix is what a closer's indentation is measured against.
+ */
 export type OpenFence = {
     char: string;
     length: number;
+    prefix: string;
 } | null;
 /**
  * Fence tracking, one line at a time: returns the fence state after `line`.
@@ -9,6 +14,12 @@ export type OpenFence = {
  * "am I inside a fence" answer can never drift between them.
  */
 export declare const trackFence: (line: string, open: OpenFence) => OpenFence;
+/**
+ * The line that closes `open`, placed at the opener's depth so it closes the
+ * fence where it lives. A list marker in the prefix is blanked to spaces: a
+ * closer must sit inside the item, and a repeated marker would start a new one.
+ */
+export declare const closingFence: (open: NonNullable<OpenFence>) => string;
 /**
  * True when `raw` ends inside a fenced block — i.e. the fence is still being
  * streamed. Only the last block of a live document can be in this state.

package/dist/utils/fence.js

@@ -1,31 +1,48 @@
-// Up to 3 spaces of indentation per CommonMark; blockquote markers are stripped
-// too because a fence can be quoted ("> ```") inside a blockquote or an alert,
-// and so is a leading list marker, because "- ```js" opens a fence in the item.
-const FENCE_LINE = /^[ \t]{0,3}(?:>[ \t]*)*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+)?(`{3,}|~{3,})(.*)$/;
+// An opener may sit behind up to 3 spaces of indentation per CommonMark, behind
+// blockquote markers ("> ```" inside a blockquote or an alert), and behind a
+// list marker, because "- ```js" opens a fence in the item.
+const OPENER_LINE = /^([ \t]{0,3}(?:>[ \t]*)*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+)?)(`{3,}|~{3,})(.*)$/;
+// A closer is measured against the opener, not against column 0: it may be
+// indented up to 3 spaces more than the opener was. That is what makes a fence
+// inside a list item close — "10. ```js" opens at column 4, so its "    ```"
+// closer is at 4, which a fixed 0–3 limit rejected.
+const CLOSER_LINE = /^([ \t]*(?:>[ \t]*)*)(`{3,}|~{3,})[ \t]*$/;
 /**
  * Fence tracking, one line at a time: returns the fence state after `line`.
  * The completer's block scan and `hasUnclosedFence` both walk with this, so the
  * "am I inside a fence" answer can never drift between them.
  */
 export const trackFence = (line, open) => {
-    const match = FENCE_LINE.exec(line);
-    if (!match) {
-        return open;
-    }
-    const run = match[1];
-    const info = match[2];
     if (open) {
-        // A closer uses the opener's character, is at least as long, and carries no
-        // info string — so a shorter fence line inside a longer block is content.
-        return run[0] === open.char && run.length >= open.length && info.trim() === '' ? null : open;
+        // A closer uses the opener's character, is at least as long, carries no
+        // info string, and is not indented deeper than the opener plus 3 — so a
+        // shorter or deeper fence line inside the block is content.
+        const match = CLOSER_LINE.exec(line);
+        if (!match)
+            return open;
+        const run = match[2];
+        const closes = run[0] === open.char &&
+            run.length >= open.length &&
+            match[1].length <= open.prefix.length + 3;
+        return closes ? null : open;
     }
+    const match = OPENER_LINE.exec(line);
+    if (!match)
+        return null;
+    const run = match[2];
     // A backtick fence's info string cannot contain a backtick (marked's own rule),
     // so such a line opens nothing.
-    if (run[0] === '`' && info.includes('`')) {
-        return open;
-    }
-    return { char: run[0], length: run.length };
+    if (run[0] === '`' && match[3].includes('`'))
+        return null;
+    return { char: run[0], length: run.length, prefix: match[1] };
 };
+/**
+ * The line that closes `open`, placed at the opener's depth so it closes the
+ * fence where it lives. A list marker in the prefix is blanked to spaces: a
+ * closer must sit inside the item, and a repeated marker would start a new one.
+ */
+export const closingFence = (open) => open.prefix.replace(/[-*+]|\d{1,9}[.)]/g, (marker) => ' '.repeat(marker.length)) +
+    open.char.repeat(open.length);
 /**
  * True when `raw` ends inside a fenced block — i.e. the fence is still being
  * streamed. Only the last block of a live document can be in this state.

package/dist/utils/line-numbers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Line-number options carried by a fence's info string. `token.lang` is the first
+ * word and `token.meta` the rest since 4.0.1, so this only ever sees the rest —
+ * `startLine=10 noLineNumbers` out of a ```ts fence.
+ *
+ * `lineNumbers` / `noLineNumbers` are upstream streamdown's per-block escape
+ * hatches; ours flip the `lineNumbers` prop either way because our prop defaults
+ * to false (upstream defaults to on).
+ *
+ * The rendering side is CSS counters on the per-line span that is already there
+ * (`counter-increment` + a `::before` printing `counter(sd-line)`, in the global
+ * block of Streamdown.svelte; `counter-reset` inline on the <pre> so `startLine`
+ * can move it): no element per line, and a pseudo-element's content is never part
+ * of a selection, so copy/download — which read the token text anyway — can never
+ * pick numbers up. The counter rule cannot live in the theme like the gutter's
+ * width and colour (`theme.code.lineNumber`), because a Tailwind
+ * `before:content-[counter(sd-line)]` class only exists if the consumer's
+ * Tailwind scanned this package.
+ */
+export declare const resolveLineNumbers: (meta: string | undefined, enabled: boolean) => {
+    enabled: boolean;
+    start: number;
+};

package/dist/utils/line-numbers.js

@@ -0,0 +1,30 @@
+/**
+ * Line-number options carried by a fence's info string. `token.lang` is the first
+ * word and `token.meta` the rest since 4.0.1, so this only ever sees the rest —
+ * `startLine=10 noLineNumbers` out of a ```ts fence.
+ *
+ * `lineNumbers` / `noLineNumbers` are upstream streamdown's per-block escape
+ * hatches; ours flip the `lineNumbers` prop either way because our prop defaults
+ * to false (upstream defaults to on).
+ *
+ * The rendering side is CSS counters on the per-line span that is already there
+ * (`counter-increment` + a `::before` printing `counter(sd-line)`, in the global
+ * block of Streamdown.svelte; `counter-reset` inline on the <pre> so `startLine`
+ * can move it): no element per line, and a pseudo-element's content is never part
+ * of a selection, so copy/download — which read the token text anyway — can never
+ * pick numbers up. The counter rule cannot live in the theme like the gutter's
+ * width and colour (`theme.code.lineNumber`), because a Tailwind
+ * `before:content-[counter(sd-line)]` class only exists if the consumer's
+ * Tailwind scanned this package.
+ */
+export const resolveLineNumbers = (meta, enabled) => {
+    // The tests are case-sensitive and `noLineNumbers` spells the word with a
+    // capital L, so the positive test can never match it; checked first anyway.
+    const on = meta
+        ? /\bnoLineNumbers\b/.test(meta)
+            ? false
+            : /\blineNumbers\b/.test(meta) || enabled
+        : enabled;
+    const start = meta?.match(/\bstartLine=(\d+)\b/);
+    return { enabled: on, start: start ? Number(start[1]) : 1 };
+};

package/dist/utils/normalize-html-indentation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Four leading spaces after a blank line is an indented code block, HTML or not.
+ * A pretty-printed document therefore splits into html / code / html and the
+ * indented part renders as source in a code box (upstream 7f9127b).
+ *
+ * This strips the indentation off tag lines only. It is lossy inside `<pre>` and
+ * `<code>`, where whitespace is content, so those bodies are skipped and the
+ * whole thing is behind the opt-in `normalizeHtmlIndentation` prop.
+ */
+export declare const normalizeHtmlIndentation: (content: string) => string;