svelte-streamdown 4.0.1 → 4.1.0

package/dist/Elements/icons.js

@@ -4,6 +4,7 @@ export const copyIcon = createRawSnippet(() => {
         render: () => {
             return `
             <svg
+	aria-hidden="true"
 	xmlns="http://www.w3.org/2000/svg"
 	width="100%"
 	height="100%"
@@ -24,6 +25,7 @@ export const downloadIcon = createRawSnippet(() => {
     return {
         render: () => {
             return `<svg
+	aria-hidden="true"
 		xmlns="http://www.w3.org/2000/svg"
 		width="100%"
 		height="100%"
@@ -44,7 +46,8 @@ export const checkIcon = createRawSnippet(() => {
     return {
         render: () => {
             return `
-            <svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>
+            <svg
+	aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>
             `;
         }
     };
@@ -53,6 +56,7 @@ export const zoomInIcon = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				width="100%"
 				height="100%"
 				viewBox="0 0 24 24"
@@ -75,6 +79,7 @@ export const zoomOutIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -96,6 +101,7 @@ export const fitViewIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -119,6 +125,7 @@ export const fullscreenIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -139,6 +146,7 @@ export const chevronRight = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				xmlns="http://www.w3.org/2000/svg"
 				width="100%"
 				height="100%"
@@ -158,6 +166,7 @@ export const chevronLeft = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				xmlns="http://www.w3.org/2000/svg"
 				width="100%"
 				height="100%"

package/dist/Elements/srOnly.d.ts

@@ -0,0 +1 @@
+export declare const srOnly = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;";

package/dist/Elements/srOnly.js

@@ -0,0 +1,3 @@
+// Visually hidden but announced. Inline rather than a theme class: a live region
+// must keep working in apps that do not ship Tailwind's `sr-only`.
+export const srOnly = 'position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;';

package/dist/Streamdown.svelte

@@ -1,8 +1,13 @@
 <script lang="ts" generics="Source extends Record<string, any> = Record<string, any>">
 	import Block from './Block.svelte';
-	import { StreamdownContext, type StreamdownProps } from './context.svelte.js';
+	import {
+		StreamdownContext,
+		defaultTranslations,
+		type StreamdownProps
+	} from './context.svelte.js';
 	import { mergeTheme, shadcnTheme } from './theme.js';
 	import { parseBlocks, createParseBlocksCache } from './marked/index.js';
+	import { hasUnclosedFence } from './utils/fence.js';
 
 	let {
 		content = '',
@@ -23,6 +28,8 @@
 		streamdown = $bindable(),
 		renderHtml,
 		controls,
+		codeBlockMaxHeight,
+		tableMaxHeight,
 		animation,
 		element = $bindable(),
 		icons,
@@ -94,7 +101,11 @@
 			return renderHtml;
 		},
 		get translations() {
-			return translations;
+			// Resolved once, like the theme, so components never fall back themselves.
+			return {
+				alert: { ...defaultTranslations.alert, ...translations?.alert },
+				controls: { ...defaultTranslations.controls, ...translations?.controls }
+			};
 		},
 		get highlightLanguages() {
 			return highlightLanguages;
@@ -123,19 +134,53 @@
 			};
 		},
 		get controls() {
-			const codeControls = controls?.code ?? true;
-			const mermaid = controls?.mermaid;
-			const isMermaidObject = typeof mermaid === 'object' && mermaid !== null;
-			const mermaidControls = isMermaidObject ? (mermaid.enabled ?? true) : (mermaid ?? true);
-			const mermaidMouseWheelZoom = isMermaidObject ? (mermaid.mouseWheelZoom ?? true) : true;
-			const tableControls = controls?.table ?? true;
+			// `controls` is sugar: `false` turns every control off, `true`/undefined
+			// turns them all on, and each section is a boolean or an object of the
+			// same shape. Flatten it once here so components stay boolean lookups.
+			const sections = typeof controls === 'object' && controls !== null ? controls : {};
+			const resolve = (section: boolean | Record<string, any> | undefined) => {
+				const config = typeof section === 'object' && section !== null ? section : {};
+				const enabled = controls === false || section === false ? false : (config.enabled ?? true);
+				const download = config.download;
+				return {
+					enabled,
+					copy: enabled && config.copy !== false,
+					download: enabled && download !== false,
+					filename:
+						typeof download === 'object' && download !== null ? download.filename : undefined
+				};
+			};
+			const code = resolve(sections.code);
+			const table = resolve(sections.table);
+			const mermaid = resolve(sections.mermaid);
+			const tableSection =
+				typeof sections.table === 'object' && sections.table ? sections.table : {};
+			const mermaidSection =
+				typeof sections.mermaid === 'object' && sections.mermaid ? sections.mermaid : {};
 			return {
-				code: codeControls,
-				mermaid: mermaidControls,
-				mermaidMouseWheelZoom,
-				table: tableControls
+				code: code.enabled,
+				codeCopy: code.copy,
+				codeDownload: code.download,
+				codeDownloadFilename: code.filename ?? 'file',
+				table: table.enabled,
+				tableCopy: table.copy,
+				tableDownload: table.download,
+				tableDownloadFilename: table.filename ?? 'table',
+				tableCsvSeparator: tableSection.csvSeparator ?? ',',
+				mermaid: mermaid.enabled,
+				mermaidDownload: mermaid.download,
+				mermaidDownloadFilename: mermaid.filename ?? 'diagram',
+				// Wheel zoom is a gesture, not a button: it stays on unless it is
+				// turned off explicitly or every control is.
+				mermaidMouseWheelZoom: controls !== false && mermaidSection.mouseWheelZoom !== false
 			};
 		},
+		get codeBlockMaxHeight() {
+			return codeBlockMaxHeight;
+		},
+		get tableMaxHeight() {
+			return tableMaxHeight;
+		},
 		get children() {
 			return children;
 		},
@@ -161,6 +206,12 @@
 	const blocks = $derived(
 		isStatic ? content : parseBlocks(content, streamdown.extensions, blocksCache)
 	);
+
+	// Only the tail of a live stream can be mid-fence — a static render is finished
+	// by definition. Computed once here, not per block or per token.
+	const lastBlockIncomplete = $derived(
+		!isStatic && blocks.length > 0 && hasUnclosedFence(blocks[blocks.length - 1])
+	);
 </script>
 
 <div bind:this={element} class={className}>
@@ -168,7 +219,11 @@
 		<Block static={isStatic} block={content} />
 	{:else}
 		{#each blocks as block, index (`${id}-block-${index}`)}
-			<Block static={isStatic} {block} />
+			<Block
+				static={isStatic}
+				{block}
+				incomplete={lastBlockIncomplete && index === blocks.length - 1}
+			/>
 		{/each}
 	{/if}
 </div>

package/dist/context.svelte.d.ts

@@ -4,16 +4,55 @@ import type { MermaidConfig } from 'mermaid';
 import type { KatexOptions } from 'katex';
 import type { HighlightTheme } from '@tanstack/highlight/theme';
 import type { LanguageDefinition } from '@tanstack/highlight';
+/**
+ * Every user-visible string the components render themselves. Nested by area,
+ * like the theme; `Streamdown` merges the `translations` prop over
+ * `defaultTranslations` once so components always read a complete object.
+ */
+export type Translations = {
+    alert: {
+        note: string;
+        tip: string;
+        warning: string;
+        caution: string;
+        important: string;
+    };
+    controls: {
+        copyCode: string;
+        copiedCode: string;
+        downloadCode: string;
+        copyTable: string;
+        copiedTable: string;
+        downloadTable: string;
+        tableFormatMarkdown: string;
+        tableFormatHtml: string;
+        tableFormatCsv: string;
+        tableFormatTsv: string;
+        downloadDiagram: string;
+        downloadDiagramPng: string;
+        downloadDiagramSvg: string;
+        downloadDiagramMmd: string;
+        zoomIn: string;
+        zoomOut: string;
+        resetView: string;
+        fullscreen: string;
+        exitFullscreen: string;
+        diagram: string;
+        previousCitation: string;
+        nextCitation: string;
+        blockedUrl: string;
+        imageBlocked: string;
+        imageNoDescription: string;
+        linkBlocked: string;
+    };
+};
+export declare const defaultTranslations: Translations;
 export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'highlightTheme' | 'inlineCitationsMode'> {
     snippets: Snippets;
     highlightTheme: HighlightTheme;
     theme: Theme;
-    controls: {
-        code: boolean;
-        mermaid: boolean;
-        mermaidMouseWheelZoom: boolean;
-        table: boolean;
-    };
+    translations: Translations;
+    controls: ResolvedControls;
     inlineCitationsMode: 'list' | 'carousel';
     animation: {
         enabled: boolean;
@@ -33,8 +72,9 @@ export declare class StreamdownContext<Source extends Record<string, any> = Reco
     });
 }
 export declare const useStreamdown: () => StreamdownContext<Record<string, any>>;
-import type { AlertToken, MathToken, SubSupToken, TableToken, THead, TBody, TFoot, THeadRow, TRow, TD, TH, Extension, GenericToken, CitationToken, MdxToken } from './marked/index.js';
+import type { AlertToken, CodeToken, MathToken, SubSupToken, TableToken, THead, TBody, TFoot, THeadRow, TRow, TD, TH, Extension, GenericToken, CitationToken, MdxToken } from './marked/index.js';
 import type { Tokens } from 'marked';
+import type { CsvSeparator } from './utils/table-export.js';
 import type { ListItemToken, ListToken } from './marked/marked-list.js';
 import type { Footnote, FootnoteRef, FootnoteToken } from './marked/marked-footnotes.js';
 import type { DescriptionDetailToken, DescriptionListToken, DescriptionTermToken, DescriptionToken } from './marked/marked-dl.js';
@@ -89,9 +129,53 @@ export type Snippets<Source extends Record<string, any> = Record<string, any>> =
             key: string;
         } : K extends 'mdx' ? {
             props: Record<string, number | string | boolean | null | undefined>;
+        } : K extends 'code' | 'mermaid' ? {
+            /** The fence is still streaming: defer expensive work. */
+            incomplete: boolean;
         } : {})
     ]>;
 };
+/** `filename` is the base name; the extension comes from the format. */
+type DownloadControl<Token> = boolean | {
+    filename?: string | ((token: Token) => string);
+};
+export type CodeControls = boolean | {
+    enabled?: boolean;
+    copy?: boolean;
+    download?: DownloadControl<CodeToken>;
+};
+export type TableControls = boolean | {
+    enabled?: boolean;
+    copy?: boolean;
+    download?: DownloadControl<TableToken>;
+    csvSeparator?: CsvSeparator;
+};
+export type MermaidControls = boolean | {
+    enabled?: boolean;
+    download?: DownloadControl<CodeToken>;
+    mouseWheelZoom?: boolean;
+};
+export type Controls = boolean | {
+    code?: CodeControls;
+    table?: TableControls;
+    mermaid?: MermaidControls;
+};
+/** What `Streamdown.svelte` flattens `controls` into, so components stay dumb. */
+export type ResolvedControls = {
+    code: boolean;
+    codeCopy: boolean;
+    codeDownload: boolean;
+    codeDownloadFilename: string | ((token: CodeToken) => string);
+    table: boolean;
+    tableCopy: boolean;
+    tableDownload: boolean;
+    tableDownloadFilename: string | ((token: TableToken) => string);
+    tableCsvSeparator: CsvSeparator;
+    mermaid: boolean;
+    mermaidDownload: boolean;
+    mermaidDownloadFilename: string | ((token: CodeToken) => string);
+    mermaidMouseWheelZoom: boolean;
+};
 export type StreamdownProps<Source extends Record<string, any> = Record<string, any>> = {
     streamdown?: StreamdownContext;
     static?: boolean;
@@ -114,23 +198,13 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
     highlightThemes?: Record<string, HighlightTheme>;
     mermaidConfig?: MermaidConfig;
     katexConfig?: KatexOptions | ((inline: boolean) => KatexOptions);
+    /** Partial overrides; unset keys fall back to `defaultTranslations`. */
     translations?: {
-        alert?: {
-            note?: string;
-            tip?: string;
-            warning?: string;
-            caution?: string;
-            important?: string;
-        };
-    };
-    controls?: {
-        code?: boolean;
-        mermaid?: boolean | {
-            enabled?: boolean;
-            mouseWheelZoom?: boolean;
-        };
-        table?: boolean;
+        [K in keyof Translations]?: Partial<Translations[K]>;
     };
+    controls?: Controls;
+    codeBlockMaxHeight?: string;
+    tableMaxHeight?: string;
     renderHtml?: boolean | ((token: Tokens.HTML | Tokens.Tag) => string);
     animation?: {
         animateOnMount?: boolean;
@@ -171,10 +245,12 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
         code?: Component<{
             token: Tokens.Code;
             id: string;
+            incomplete: boolean;
         }, any, any>;
         mermaid?: Component<{
             token: Tokens.Code;
             id: string;
+            incomplete: boolean;
         }, any, any>;
         math?: Component<{
             token: MathToken;

package/dist/context.svelte.js

@@ -1,4 +1,42 @@
 import { getContext, onMount, setContext } from 'svelte';
+// Alert titles stay lowercase: the theme capitalizes them with CSS.
+export const defaultTranslations = {
+    alert: {
+        note: 'note',
+        tip: 'tip',
+        warning: 'warning',
+        caution: 'caution',
+        important: 'important'
+    },
+    controls: {
+        copyCode: 'Copy code',
+        copiedCode: 'Code copied',
+        downloadCode: 'Download code',
+        copyTable: 'Copy table',
+        copiedTable: 'Table copied',
+        downloadTable: 'Download table',
+        tableFormatMarkdown: 'Markdown',
+        tableFormatHtml: 'HTML',
+        tableFormatCsv: 'CSV',
+        tableFormatTsv: 'TSV',
+        downloadDiagram: 'Download diagram',
+        downloadDiagramPng: 'PNG',
+        downloadDiagramSvg: 'SVG',
+        downloadDiagramMmd: 'MMD',
+        zoomIn: 'Zoom in',
+        zoomOut: 'Zoom out',
+        resetView: 'Zoom to fit',
+        fullscreen: 'Expand diagram',
+        exitFullscreen: 'Collapse diagram',
+        diagram: 'Diagram',
+        previousCitation: 'Previous citation',
+        nextCitation: 'Next citation',
+        blockedUrl: 'Blocked URL',
+        imageBlocked: 'Image blocked',
+        imageNoDescription: 'No description',
+        linkBlocked: 'blocked'
+    }
+};
 export class StreamdownContext {
     footnotes = {
         refs: new Map(),

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { default as Streamdown } from './Streamdown.svelte';
-export { useStreamdown, type StreamdownProps } from './context.svelte.js';
+export { useStreamdown, defaultTranslations, type StreamdownProps, type Translations, type Controls, type CodeControls, type TableControls, type MermaidControls, type ResolvedControls } from './context.svelte.js';
+export { extractTableData, tableDataToCSV, tableDataToTSV, tableDataToMarkdown, tableDataToHTML, type TableData, type CsvSeparator } from './utils/table-export.js';
 export { theme, shadcnTheme, mergeTheme, type Theme } from './theme.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';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { default as Streamdown } from './Streamdown.svelte';
-export { useStreamdown } from './context.svelte.js';
+export { useStreamdown, defaultTranslations } from './context.svelte.js';
+export { extractTableData, tableDataToCSV, tableDataToTSV, tableDataToMarkdown, tableDataToHTML } from './utils/table-export.js';
 export { theme, shadcnTheme, mergeTheme } from './theme.js';
 export { lex, parseBlocks } from './marked/index.js';
 export { parseIncompleteMarkdown, IncompleteMarkdownParser } from './utils/parse-incomplete-markdown.js';

package/dist/marked/index.js

@@ -151,9 +151,10 @@ export const createParseBlocksCache = () => ({
 // 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;
-// 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.
+// Stride spot checks over the sealed prefix per append (see `appendable`), on
+// top of the per-block-start probes. 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.
@@ -185,23 +186,37 @@ const blockTokensOf = (markdown, extensions) => new SplitLexer(getBlockOptions(e
  * 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).
+ * the only region whose segmentation can still change. The sealed prefix is only
+ * sampled, never scanned: 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).
+ *
+ * Two families of samples, both O(sealed blocks) and not O(sealed characters):
+ * the first character of every sealed block (`cache.offsets` already holds those
+ * positions), which catches any edit that moves a block boundary or rewrites a
+ * block's first character — the shape a real out-of-band edit takes; plus
+ * SEAL_PROBES evenly spaced characters, which catch a wholesale document swap.
+ * A same-length edit in the middle of a sealed block can still slip through; see
+ * the streaming contract in the README.
  *
  * 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) => {
+const appendable = (markdown, cache, cut, offset) => {
+    const content = cache.content;
     for (let i = offset; i < content.length; i++) {
         if (markdown.charCodeAt(i) !== content.charCodeAt(i))
             return false;
     }
     if (offset === 0)
         return true;
+    for (let b = 0; b < cut; b++) {
+        const i = cache.offsets[b];
+        if (markdown.charCodeAt(i) !== content.charCodeAt(i))
+            return false;
+    }
     const step = offset > SEAL_PROBES ? offset / SEAL_PROBES : 1;
     for (let f = 0; f < offset; f += step) {
         const i = f | 0;
@@ -223,7 +238,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
                 liveBlocks++;
         }
         const offset = cache.offsets[cut];
-        if (appendable(markdown, cache.content, offset)) {
+        if (appendable(markdown, cache, cut, offset)) {
             const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
             let tailLength = 0;
             for (const token of tailTokens)

package/dist/marked/marked-math.js

@@ -4,6 +4,13 @@ const blockRule = /^(\$\$)(?:\n((?:\\[\s\S]|[^\\])+?)\n\1(?:\n|$)|([^$\n]+?)\1(?
 // Inline math: handles both single ($) and double ($$) dollar delimiters
 // Avoids matching currency by checking context and requiring proper content
 const inlineRule = /^(\${1,2})(?!\$)((?:[^$\n]|\\\$)*?)\1(?!\d)/;
+// LaTeX delimiters. LLMs emit these as often as dollars, so they produce the
+// same `math` token: `\(`/`\)` inline, `\[`/`\]` display. Only the block form
+// may span lines; an escaped backslash (`\\(`) is not a delimiter, which the
+// charCode dispatch below rejects before any regex runs.
+const inlineParenRule = /^\\\(([^\n]*?)\\\)/;
+const inlineBracketRule = /^\\\[([^\n]*?)\\\]/;
+const blockBracketRule = /^\\\[([\s\S]+?)\\\](?:\n|$)/;
 // Enhanced currency detection patterns
 const currencyPatterns = {
     // Simple price patterns: $123, $123.45, $1,234.56
@@ -20,6 +27,20 @@ export const markedMath = [
         name: 'math',
         level: 'block',
         tokenizer(src) {
+            if (src.charCodeAt(0) === 92 /* \ */) {
+                if (src.charCodeAt(1) !== 91 /* [ */)
+                    return;
+                const latex = src.match(blockBracketRule);
+                if (!latex)
+                    return;
+                return {
+                    type: 'math',
+                    isInline: false,
+                    displayMode: true,
+                    raw: latex[0],
+                    text: latex[1].trim()
+                };
+            }
             if (src.charCodeAt(0) !== 36 /* $ */)
                 return;
             const match = src.match(blockRule);
@@ -69,7 +90,25 @@ export const markedMath = [
             }
         },
         tokenizer(src) {
-            // inlineRule is anchored on `$`; skip the regex otherwise (see marked-br.ts).
+            // The rules are anchored on their opening delimiter; skip the regex
+            // otherwise (see marked-br.ts) — this runs at every inline scan position.
+            if (src.charCodeAt(0) === 92 /* \ */) {
+                const open = src.charCodeAt(1);
+                // `\\(` is an escaped backslash followed by a paren, never math.
+                const displayMode = open === 91; /* [ */
+                if (!displayMode && open !== 40 /* ( */)
+                    return;
+                const latex = src.match(displayMode ? inlineBracketRule : inlineParenRule);
+                if (!latex)
+                    return;
+                return {
+                    type: 'math',
+                    isInline: true,
+                    displayMode,
+                    raw: latex[0],
+                    text: latex[1].trim()
+                };
+            }
             if (src.charCodeAt(0) !== 36 /* $ */)
                 return;
             const match = src.match(inlineRule);

package/dist/utils/fence.d.ts

@@ -0,0 +1,16 @@
+/** An open code fence: the character it was opened with, and its run length. */
+export type OpenFence = {
+    char: string;
+    length: number;
+} | null;
+/**
+ * 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 declare const trackFence: (line: string, open: OpenFence) => OpenFence;
+/**
+ * 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.
+ */
+export declare const hasUnclosedFence: (raw: string) => boolean;

package/dist/utils/fence.js

@@ -0,0 +1,39 @@
+// 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,})(.*)$/;
+/**
+ * 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 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 };
+};
+/**
+ * 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.
+ */
+export const hasUnclosedFence = (raw) => {
+    let open = null;
+    for (const line of raw.split('\n')) {
+        open = trackFence(line, open);
+    }
+    return open !== null;
+};

package/dist/utils/parse-incomplete-markdown.d.ts

@@ -1,3 +1,4 @@
+import { type OpenFence } from './fence.js';
 export interface Plugin {
     name: string;
     pattern?: RegExp;
@@ -25,13 +26,16 @@ interface ParseState {
     currentLine: number;
     context: 'normal' | 'list' | 'blockquote' | 'descriptionList';
     blockingContexts: Set<'code' | 'math' | 'center' | 'right'>;
+    /** Delimiter that closes the open math block: '$$' or '\]'. */
+    mathCloser?: '$$' | '\\]';
+    /** The fence still open at the end of the input, if any — what closes it. */
+    openFence?: OpenFence;
     lineContexts?: Array<{
         code: boolean;
         math: boolean;
         center: boolean;
         right: boolean;
     }>;
-    fenceInfo?: string;
     mdxUnclosedTags?: Array<{
         tagName: string;
         lineIndex: number;