@antdv-next/x-markdown 0.2.0 → 0.3.0

package/dist/XMarkdown/composables/useStreaming.js

@@ -1,6 +1,10 @@
+import { detectUnclosedComponentTags, hasUnclosedRawTags } from "../core/detectUnclosedComponentTags.js";
 import { StreamCacheTokenType } from "../interface.js";
-import { ref, watch } from "vue";
+import { resolveStreaming } from "../utils/streaming.js";
+import { computed, ref, watch } from "vue";
+import { Marked, walkTokens } from "marked";
 //#region src/XMarkdown/composables/useStreaming.ts
+var HEADING_LINE = /^#{1,6}(?:[ \t]|$)/;
 var STREAM_INCOMPLETE_REGEX = {
 	image: [/^!\[[^\]\r\n]{0,1000}$/, /^!\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
 	link: [/^\[[^\]\r\n]{0,1000}$/, /^\[[^\r\n]{0,1000}\]\(*[^)\r\n]{0,1000}$/],
@@ -9,17 +13,25 @@ var STREAM_INCOMPLETE_REGEX = {
 	list: [/^[-+*]\s{0,3}$/, /^[-+*]\s{1,3}(\*{1,3}|_{1,3})(?!\s)(?!.*\1$)[^\r\n]{0,1000}$/],
 	"inline-code": [/^`[^`\r\n]{0,300}$/]
 };
-var isTableInComplete = (markdown) => {
-	if (markdown.includes("\n\n")) return false;
-	const lines = markdown.split("\n");
-	if (lines.length <= 1) return true;
-	const [header, separator] = lines;
+/** Header + delimiter row shape check. Cost is bounded by those two rows, not by pending. */
+var isTableShapeValid = (header, separator) => {
 	const trimmedHeader = header.trim();
 	if (!/^\|.*\|$/.test(trimmedHeader)) return false;
 	const columns = separator.trim().split("|").map((col) => col.trim()).filter(Boolean);
 	const separatorRegex = /^:?-+:?$/;
 	return columns.every((col, index) => index === columns.length - 1 ? col === ":" || separatorRegex.test(col) : separatorRegex.test(col));
 };
+/**
+* Same verdict as scanning the whole pending buffer, but read off the
+* incrementally maintained state instead — O(1) once the delimiter row is
+* terminated, which is where a long table spends all of its characters.
+*/
+var isTableInComplete = (table) => {
+	if (table.hasBlankLine) return false;
+	if (table.newlines === 0) return true;
+	if (table.shape !== null) return table.shape;
+	return isTableShapeValid(table.firstLine, table.secondLine);
+};
 var tokenRecognizerMap = {
 	[StreamCacheTokenType.Link]: {
 		tokenType: StreamCacheTokenType.Link,
@@ -54,7 +66,7 @@ var tokenRecognizerMap = {
 	[StreamCacheTokenType.Table]: {
 		tokenType: StreamCacheTokenType.Table,
 		isStartOfToken: (markdown) => markdown.startsWith("|"),
-		isStreamingValid: isTableInComplete
+		isStreamingValid: (_markdown, cache) => isTableInComplete(cache.table)
 	},
 	[StreamCacheTokenType.InlineCode]: {
 		tokenType: StreamCacheTokenType.InlineCode,
@@ -70,11 +82,12 @@ var recognize = (cache, tokenType) => {
 		cache.token = tokenType;
 		return;
 	}
-	if (token === tokenType && !recognizer.isStreamingValid(pending)) {
+	if (token === tokenType && !recognizer.isStreamingValid(pending, cache)) {
 		const prefix = recognizer.getCommitPrefix?.(pending);
 		if (prefix) {
 			cache.completeMarkdown += prefix;
 			cache.pending = pending.slice(prefix.length);
+			rebuildTableState(cache.table, cache.pending);
 			cache.token = StreamCacheTokenType.Text;
 			return;
 		}
@@ -86,23 +99,70 @@ var getInitialFenceState = () => ({
 	inFenced: false,
 	fenceChar: "",
 	fenceLen: 0,
+	lineIndent: 0,
 	lineFenceChar: "",
 	lineFenceLen: 0,
 	lineFenceRunEnded: false,
 	lineTailBlank: true
 });
+var getInitialTableState = () => ({
+	newlines: 0,
+	lastWasNewline: false,
+	hasBlankLine: false,
+	firstLine: "",
+	secondLine: "",
+	shape: null
+});
+var resetTableState = (table) => {
+	table.newlines = 0;
+	table.lastWasNewline = false;
+	table.hasBlankLine = false;
+	table.firstLine = "";
+	table.secondLine = "";
+	table.shape = null;
+};
+/** Advance the table state by one appended character. O(1). */
+var feedTableState = (table, char) => {
+	if (char === "\n") {
+		if (table.lastWasNewline) table.hasBlankLine = true;
+		table.lastWasNewline = true;
+		table.newlines += 1;
+		if (table.newlines === 2) table.shape = isTableShapeValid(table.firstLine, table.secondLine);
+		return;
+	}
+	table.lastWasNewline = false;
+	if (table.newlines === 0) table.firstLine += char;
+	else if (table.newlines === 1) table.secondLine += char;
+};
+/** Rebuild from scratch. Only used when pending is replaced instead of appended to. */
+var rebuildTableState = (table, pending) => {
+	resetTableState(table);
+	for (const char of pending) feedTableState(table, char);
+};
+var getInitialSectionState = () => ({
+	offsets: [],
+	lineStart: 0,
+	noSplit: false,
+	sawDefinitionTrigger: false,
+	definitionCheckedLength: -1,
+	rawBlock: null,
+	openBlock: null
+});
 var getInitialCache = () => ({
 	pending: "",
 	token: StreamCacheTokenType.Text,
 	processedLength: 0,
 	completeMarkdown: "",
-	fence: getInitialFenceState()
+	fence: getInitialFenceState(),
+	table: getInitialTableState(),
+	sections: getInitialSectionState()
 });
 var commitCache = (cache) => {
 	if (cache.pending) {
 		cache.completeMarkdown += cache.pending;
 		cache.pending = "";
 	}
+	resetTableState(cache.table);
 	cache.token = StreamCacheTokenType.Text;
 };
 /**
@@ -124,13 +184,15 @@ var feedFenceState = (fence, char) => {
 				fence.fenceLen = 0;
 			}
 		}
+		fence.lineIndent = 0;
 		fence.lineFenceChar = "";
 		fence.lineFenceLen = 0;
 		fence.lineFenceRunEnded = false;
 		fence.lineTailBlank = true;
 		return;
 	}
-	if (!fence.lineFenceRunEnded) if (fence.lineFenceLen === 0 && (char === "`" || char === "~")) {
+	if (!fence.lineFenceRunEnded) if (fence.lineFenceLen === 0 && char === " " && fence.lineIndent < 3) fence.lineIndent += 1;
+	else if (fence.lineFenceLen === 0 && (char === "`" || char === "~")) {
 		fence.lineFenceChar = char;
 		fence.lineFenceLen = 1;
 	} else if (fence.lineFenceLen > 0 && char === fence.lineFenceChar) fence.lineFenceLen += 1;
@@ -141,6 +203,304 @@ var feedFenceState = (fence, char) => {
 	else fence.lineTailBlank = fence.lineTailBlank && /\s/.test(char);
 };
 var isInCodeBlock = (fence) => fence.inFenced || fence.lineFenceLen >= 3;
+/** Sections shorter than this are merged into the next one. */
+var DEFAULT_MIN_SECTION_CHARS = 200;
+var DEFINITION_TRIGGER = /\]:/;
+/** Raw HTML blocks whose end condition may span blank lines (CommonMark 1–2/3–5). */
+var RAW_HTML_BLOCK_OPEN = /^ {0,3}<(pre|script|style|textarea)(?=[\s>]|$)/i;
+var HTML_COMMENT_OPEN = /^ {0,3}<!--/;
+var HTML_PI_OPEN = /^ {0,3}<\?/;
+var HTML_DECLARATION_OPEN = /^ {0,3}<![a-zA-Z]/;
+var HTML_CDATA_OPEN = /^ {0,3}<!\[CDATA\[/;
+var MATH_DOLLAR_LINE = /^(\${1,2})$/;
+var MATH_BRACKET_OPEN = /^\\\[/;
+/**
+* The close condition of a raw block opened by `line`, or null. A block that
+* already closed on its own line (`<pre>x</pre>`, `<!-- x -->`) is not open.
+*/
+var detectRawBlockOpen = (line) => {
+	const html = line.match(RAW_HTML_BLOCK_OPEN);
+	if (html) {
+		const close = `</${html[1].toLowerCase()}`;
+		return line.toLowerCase().includes(close) ? null : {
+			close,
+			exact: false
+		};
+	}
+	if (HTML_COMMENT_OPEN.test(line)) return line.includes("-->") ? null : {
+		close: "-->",
+		exact: false
+	};
+	if (HTML_PI_OPEN.test(line)) return line.includes("?>") ? null : {
+		close: "?>",
+		exact: false
+	};
+	if (HTML_CDATA_OPEN.test(line)) return line.includes("]]>") ? null : {
+		close: "]]>",
+		exact: false
+	};
+	if (HTML_DECLARATION_OPEN.test(line)) return line.includes(">") ? null : {
+		close: ">",
+		exact: false
+	};
+	const dollar = line.match(MATH_DOLLAR_LINE);
+	if (dollar) return {
+		close: dollar[1],
+		exact: true,
+		bodyChars: 0
+	};
+	if (MATH_BRACKET_OPEN.test(line)) return line.includes("\\]") ? null : {
+		close: "\\]",
+		exact: false
+	};
+	return null;
+};
+/**
+* Whether `line` closes `rawBlock`. `$$` math (exact) closes only at a
+* column-0 run of the opening delimiter, matching the bundled Latex plugin.
+*/
+var closesRawBlock = (line, rawBlock) => rawBlock.exact ? line.startsWith(rawBlock.close) && !line.startsWith(`${rawBlock.close}$`) && /^[ \t]*$/.test(line.slice(rawBlock.close.length)) : line.toLowerCase().includes(rawBlock.close);
+/** How far a memoised "still inside an open block" verdict may be trusted. */
+var OPEN_BLOCK_MEMO_CHARS = 4096;
+/** The line appended to probe whether a heading starts a new top-level block. */
+var PROBE_HEADING = "# x\n";
+/**
+* Ask marked whether `prefix` plus a column-0 ATX heading parses into strictly
+* more top-level blocks than `prefix` alone — i.e. whether the heading starts a
+* new top-level block instead of being swallowed by one the prefix left open —
+* and, when it does not, whether the swallowing block is an *unclosed fenced
+* code block* (marked's last top-level token is a fenced `code` token).
+*
+* Only the second fact needs interpreting, and only to decide how long a
+* refusal may be memoised: a fence's body may contain blank lines, so a refusal
+* a fence caused survives them, while an HTML block and a table end at a blank
+* line and the refusal they caused must not. Both facts are read off marked's
+* own answers, never re-derived.
+*/
+var probeBoundary = (lex, prefix) => {
+	const blocks = lex(prefix);
+	const starts = lex(prefix + PROBE_HEADING).length > blocks.length;
+	const last = blocks[blocks.length - 1];
+	return {
+		starts,
+		fenceCause: last?.type === "code" && last.codeBlockStyle !== "indented"
+	};
+};
+/**
+* Whether `markdown` contains at least one link reference / footnote
+* definition, per the renderer's own marked. Its `links` map collects
+* definitions from any depth (`> [a]: /x`, `- [a]: /x`) and stays empty for a
+* definition-shaped line inside fence, comment, `<pre>` or math body — which
+* is exactly the distinction the tracker must make.
+*/
+var hasDefinition = (lex, markdown) => Object.keys(lex(markdown).links ?? {}).length > 0;
+/**
+* Arm the document-global "must refuse" rule's cheap gate. Called for every
+* completed line whatever block state the line is in, so a raw block or a fence
+* body can hide neither a real definition nor a definition-shaped line that is
+* really body text — the gate only decides whether to ask marked, never the
+* answer.
+*/
+var noteDefinitionTrigger = (state, line) => {
+	if (DEFINITION_TRIGGER.test(line)) state.sawDefinitionTrigger = true;
+};
+/**
+* The only document-global "must refuse" rule, settled once per pass: a link
+* reference / footnote definition can be referenced from any section, so once
+* the document contains one no boundary may be recorded and the offsets already
+* recorded are discarded.
+*
+* The question — "does the text so far contain a definition" — is asked of the
+* renderer's marked (`hasDefinition`) on the whole text. It deliberately does
+* not try to predict *where* a definition ends: marked accepts a title spanning
+* any number of lines (blank lines included), so a definition can complete
+* arbitrarily far from the `]:` line that started it, and any line count after
+* which the probe stops is a wrong boundary waiting to happen. Asking late is
+* safe: the offsets recorded before the answer arrived are discarded here and
+* `noSplit` is one-way, so a late yes still collapses the sections.
+*
+* It is also asked only when the answer can change the output: with no recorded
+* boundary `sections` is null whatever the answer, and by the end of the pass
+* the offsets include every boundary recorded during it, so a boundary that is
+* about to be used is always covered by a probe on the text that contains it.
+* (Deferring cannot miss a definition: the probe reads the whole current text,
+* not a window.) This is what keeps a long `]:`-bearing but definition-free
+* stream — a TypeScript block full of `[key: string]: T`, say — from paying one
+* whole-text lex per pass; and once a definition is found, `noSplit` closes the
+* gate for good.
+*/
+var settleDefinition = (state, text, lex) => {
+	if (state.noSplit) return;
+	if (!state.sawDefinitionTrigger || state.offsets.length === 0) return;
+	if (state.definitionCheckedLength === text.length) return;
+	state.definitionCheckedLength = text.length;
+	if (hasDefinition(lex, text)) {
+		state.noSplit = true;
+		state.offsets = [];
+		state.openBlock = null;
+	}
+};
+/**
+* Total length of the content of every code token (fenced or indented), at any
+* depth. Used only to compare the document before and after appending one line:
+* a code token that grows did not exist for that content before, so the line
+* became code body rather than a new block. Marked's own walker is used rather
+* than a hand-rolled model of the token shapes: it already knows every place a
+* child token can live (list items, table cells, extension `childTokens`).
+*/
+var codeContentLength = (tokens) => {
+	let total = 0;
+	walkTokens(tokens, (token) => {
+		if (token.type === "code") total += (token.text ?? "").length;
+	});
+	return total;
+};
+/**
+* Whether `line` (ending just past `lineEnd`) is code body per the renderer's
+* own marked. A raw-opener-shaped line that is inside a code token must not
+* open a raw block; see the call site. Appending the line can only grow code
+* content by becoming the body of an already-open fence - none of the raw
+* openers (column-0 `$`/`$$`/`\[`, up to three leading spaces before `<`) is
+* itself a fence line, so a growth here is never a new fence.
+*
+* The two lexes are whole-prefix and run for every raw-opener-shaped line, so a
+* document whose code blocks are full of column-0 `$`/`$$`/`<pre` lines pays
+* O(prefix) per such line. It is kept because the cheap fence scanner cannot
+* see a fence indented into a list item's content, and guessing wrong there
+* splits inside a real math/raw block. The fix for the cost is to derive "is
+* this line code body" from one token walk of the current prefix (marked's
+* tokens carry `raw`), not to relax the question.
+*/
+var lineIsCodeContent = (lex, text, lineStart, lineEnd) => codeContentLength(lex(text.slice(0, lineEnd))) > codeContentLength(lex(text.slice(0, lineStart)));
+/** Fallback lexer for the sections-blind `useStreaming` wrapper. */
+var fallbackLexer = (() => {
+	const marked = new Marked({ gfm: true });
+	return (markdown) => marked.lexer(markdown);
+})();
+/**
+* Called once per completed line, right after the fence state has consumed it.
+* Decides whether the line that just ended starts a new section.
+*
+* The per-line work here is O(line) — a `]:` test, a heading test and cheap
+* string guards. The marked lexes it can trigger are not, and one of them is
+* paid with `incremental` off too: a raw-opener-shaped line costs two
+* whole-prefix lexes (`lineIsCodeContent`) before the `record` gate, because
+* its answer also shapes the raw-block state a later switch-on sees. The other
+* two are gated on `record`: a candidate heading that passed every guard costs
+* O(section) (`probeBoundary`), and the document-global definition question —
+* the one probe whose cost cannot be bounded by a line count — is settled once
+* per boundary-bearing pass rather than here (`settleDefinition`).
+*/
+var trackSectionBoundary = (cache, text, newlineIndex, componentNames, minSectionChars, record, lex) => {
+	const state = cache.sections;
+	const lineStart = state.lineStart;
+	const raw = text.slice(lineStart, newlineIndex);
+	const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+	const blank = line.trim() === "";
+	state.lineStart = newlineIndex + 1;
+	if (!state.openBlock?.fenceCause && (blank || line.includes("</"))) state.openBlock = null;
+	noteDefinitionTrigger(state, line);
+	if (state.noSplit) return;
+	if (state.rawBlock) {
+		if (state.rawBlock.exact && (state.rawBlock.bodyChars ?? 0) < 2) {
+			state.rawBlock.bodyChars = (state.rawBlock.bodyChars ?? 0) + line.length + 1;
+			return;
+		}
+		if (closesRawBlock(line, state.rawBlock)) state.rawBlock = null;
+		return;
+	}
+	const rawBlock = detectRawBlockOpen(line);
+	if (rawBlock) {
+		if (lineIsCodeContent(lex, text, lineStart, newlineIndex + 1)) return;
+		state.rawBlock = rawBlock;
+		return;
+	}
+	if (!HEADING_LINE.test(line)) return;
+	if (!record) return;
+	const sectionStart = state.offsets.length ? state.offsets[state.offsets.length - 1] : 0;
+	if (lineStart <= sectionStart || lineStart - sectionStart < minSectionChars) return;
+	const sectionText = text.slice(sectionStart, lineStart);
+	if (componentNames.length > 0 && detectUnclosedComponentTags(sectionText, componentNames).size > 0) return;
+	if (sectionText.includes("<") && hasUnclosedRawTags(sectionText)) return;
+	const fenceOpen = cache.fence.inFenced;
+	const memo = state.openBlock;
+	if (memo !== null && memo.fenceOpen === fenceOpen && lineStart - memo.end < OPEN_BLOCK_MEMO_CHARS) return;
+	const { starts, fenceCause } = probeBoundary(lex, sectionText);
+	if (!starts) {
+		state.openBlock = {
+			end: lineStart,
+			fenceOpen,
+			fenceCause
+		};
+		return;
+	}
+	state.openBlock = null;
+	state.offsets.push(lineStart);
+};
+/**
+* Slice `output` at the recorded boundaries. A boundary past `limit` falls
+* inside the pending token — a heading right after a table row is held in the
+* table's pending text until the table's terminating blank line — and is left
+* for a later chunk.
+*/
+var buildSections = (cache, output, limit) => {
+	const { offsets } = cache.sections;
+	if (cache.sections.noSplit || offsets.length === 0) return null;
+	const sections = [];
+	let start = 0;
+	for (const offset of offsets) {
+		if (offset > limit) break;
+		sections.push(output.slice(start, offset));
+		start = offset;
+	}
+	if (sections.length === 0) return null;
+	sections.push(output.slice(start));
+	return sections;
+};
+var EMPHASIS_MARKER = /^(\*{1,3}|_{1,3})/;
+var INLINE_CODE_MARKER = /^`+/;
+var LIST_PREFIX = /^([-+*]\s{0,3})([\s\S]*)$/;
+var TRAILING_WHITESPACE = /\s+$/;
+/**
+* Close an emphasis run that is still open. The closing delimiter has to be
+* right-flanking (not preceded by whitespace), so trailing whitespace is moved
+* after it: `**bold and ` → `**bold and** `.
+*/
+var completeEmphasis = (pending) => {
+	const marker = pending.match(EMPHASIS_MARKER)?.[0] ?? "";
+	const body = pending.slice(marker.length);
+	const trimmed = body.replace(TRAILING_WHITESPACE, "");
+	if (!trimmed) return void 0;
+	return `${marker}${trimmed}${marker}${body.slice(trimmed.length)}`;
+};
+/**
+* Render the pending token as finished text instead of a placeholder, for the
+* `incompleteMarkdown: 'complete'` mode. Works on the pending token only, so
+* it costs O(pending) and never touches the committed text or the cache.
+* Returns undefined to keep the token hidden, exactly like placeholder mode.
+*/
+var completePending = (token, pending) => {
+	switch (token) {
+		case StreamCacheTokenType.Emphasis: return completeEmphasis(pending);
+		case StreamCacheTokenType.InlineCode: {
+			const marker = pending.match(INLINE_CODE_MARKER)?.[0] ?? "";
+			return pending.length > marker.length ? `${pending}${marker}` : void 0;
+		}
+		case StreamCacheTokenType.Link: {
+			const close = pending.indexOf("]");
+			return (close === -1 ? pending.slice(1) : pending.slice(1, close)) || void 0;
+		}
+		case StreamCacheTokenType.List: {
+			const match = pending.match(LIST_PREFIX);
+			if (!match) return void 0;
+			const [, prefix, rest] = match;
+			if (!rest) return void 0;
+			const completed = EMPHASIS_MARKER.test(rest) ? completeEmphasis(rest) : rest;
+			return completed ? `${prefix}${completed}` : void 0;
+		}
+		default: return;
+	}
+};
 var sanitizeForURIComponent = (input) => {
 	let result = "";
 	for (let i = 0; i < input.length; i++) {
@@ -162,37 +522,65 @@ var safeEncodeURIComponent = (str) => {
 		return "";
 	}
 };
-function useStreaming(content, streaming, components) {
+var resolveMinSectionChars = (incremental) => typeof incremental === "object" && typeof incremental.minSectionChars === "number" ? incremental.minSectionChars : 200;
+var resolveKeepSectionsOnEnd = (incremental) => typeof incremental === "object" ? incremental.keepSectionsOnEnd !== false : true;
+/**
+* Streaming state machine plus, when `streaming.incremental` is on, the
+* section boundaries the renderer can memoise on. `useStreaming` is the
+* backwards-compatible view of this composable.
+*/
+function useStreamingCore(content, streaming, components, lex) {
+	const resolvedStreaming = computed(() => resolveStreaming(streaming.value));
 	let streamCache = getInitialCache();
 	const processedContent = ref("");
+	const sections = ref(null);
 	function handleIncompleteMarkdown(cache, opts) {
 		const { token, pending } = cache;
 		if (token === StreamCacheTokenType.Text) return void 0;
+		/**
+		* An image tag starts with '!', if it's the only character, it's incomplete and should be stripped.
+		* ！
+		* ^
+		*/
 		if (token === StreamCacheTokenType.Image && pending === "!") return;
-		if (token === StreamCacheTokenType.Table && pending.split("\n").length > 2) return pending;
-		const componentName = opts?.incompleteMarkdownComponentMap?.[token] ?? `incomplete-${token}`;
+		/**
+		* If a table has more than two lines (header, separator, and at least one row),
+		* it's considered complete enough to not be replaced by a placeholder.
+		* | column1 | column2 |\n| -- | --|\n
+		*                                   ^
+		*/
+		if (token === StreamCacheTokenType.Table && cache.table.newlines > 1) return pending;
+		const componentMap = opts?.incompleteMarkdownComponentMap || {};
+		if (opts?.incompleteMarkdown === "complete" && !componentMap[token]) return completePending(token, pending);
+		const componentName = componentMap[token] ?? `incomplete-${token}`;
 		if (!components?.value?.[componentName]) return;
 		return `<${componentName} data-raw="${safeEncodeURIComponent(pending)}" />`;
 	}
+	/**
+	* Advance the cache to `text` and return the streaming output. It is
+	* idempotent: re-running it for the same `text` finds an empty chunk and
+	* only re-derives the output.
+	*/
 	function processStreaming(text, opts) {
 		if (!text) {
-			processedContent.value = "";
 			streamCache = getInitialCache();
-			return;
+			return "";
 		}
 		const expectedPrefix = streamCache.completeMarkdown + streamCache.pending;
 		if (!text.startsWith(expectedPrefix)) streamCache = getInitialCache();
 		const cache = streamCache;
 		const chunk = text.slice(cache.processedLength);
-		if (!chunk) {
-			const incompletePlaceholder = handleIncompleteMarkdown(cache, opts);
-			processedContent.value = cache.completeMarkdown + (incompletePlaceholder || "");
-			return;
-		}
+		const trackSections = !!opts?.incremental;
+		const minSectionChars = resolveMinSectionChars(opts?.incremental);
+		const componentNames = Object.keys(components?.value ?? {});
+		let offset = cache.processedLength;
 		cache.processedLength += chunk.length;
 		for (const char of chunk) {
 			cache.pending += char;
 			feedFenceState(cache.fence, char);
+			feedTableState(cache.table, char);
+			if (char === "\n") trackSectionBoundary(cache, text, offset, componentNames, minSectionChars, trackSections, lex);
+			offset += char.length;
 			if (isInCodeBlock(cache.fence)) {
 				commitCache(cache);
 				continue;
@@ -205,32 +593,59 @@ function useStreaming(content, streaming, components) {
 			}
 			if (cache.token === StreamCacheTokenType.Text) commitCache(cache);
 		}
+		if (cache.sections.lineStart < text.length) noteDefinitionTrigger(cache.sections, text.slice(cache.sections.lineStart));
+		settleDefinition(cache.sections, text, lex);
 		const incompletePlaceholder = handleIncompleteMarkdown(cache, opts);
-		processedContent.value = cache.completeMarkdown + (incompletePlaceholder || "");
+		return cache.completeMarkdown + (incompletePlaceholder || "");
 	}
 	function reset() {
 		streamCache = getInitialCache();
 		processedContent.value = "";
+		sections.value = null;
 	}
-	watch([content, () => streaming.value?.hasNextChunk], ([newContent, hasNextChunk]) => {
-		const opts = streaming.value;
-		if (!Boolean(hasNextChunk)) {
+	watch([
+		content,
+		() => resolvedStreaming.value?.hasNextChunk,
+		() => !!resolvedStreaming.value?.incremental,
+		() => resolveMinSectionChars(resolvedStreaming.value?.incremental),
+		() => resolveKeepSectionsOnEnd(resolvedStreaming.value?.incremental),
+		() => resolvedStreaming.value?.incompleteMarkdown,
+		() => resolvedStreaming.value?.incompleteMarkdownComponentMap,
+		() => components?.value
+	], () => {
+		const newContent = content.value;
+		const opts = resolvedStreaming.value;
+		const enableCache = Boolean(opts?.hasNextChunk);
+		const trackSections = !!opts?.incremental;
+		if (!enableCache) {
+			const cache = streamCache;
+			if (!(trackSections && !resolveKeepSectionsOnEnd(opts?.incremental)) && cache.processedLength > 0 && newContent.startsWith(cache.completeMarkdown + cache.pending)) {
+				processStreaming(newContent, opts);
+				processedContent.value = newContent;
+				sections.value = trackSections ? buildSections(cache, newContent, newContent.length) : null;
+				return;
+			}
+			streamCache = getInitialCache();
 			processedContent.value = newContent;
-			streamCache = {
-				pending: "",
-				token: StreamCacheTokenType.Text,
-				processedLength: newContent.length,
-				completeMarkdown: newContent,
-				fence: getInitialFenceState()
-			};
+			sections.value = null;
 			return;
 		}
-		processStreaming(newContent, opts);
+		const output = processStreaming(newContent, opts);
+		processedContent.value = output;
+		sections.value = trackSections ? buildSections(streamCache, output, streamCache.completeMarkdown.length) : null;
 	}, { immediate: true });
 	return {
-		processedContent,
+		output: processedContent,
+		sections,
+		reset
+	};
+}
+function useStreaming(content, streaming, components) {
+	const { output, reset } = useStreamingCore(content, streaming, components, fallbackLexer);
+	return {
+		processedContent: output,
 		reset
 	};
 }
 //#endregion
-export { useStreaming };
+export { DEFAULT_MIN_SECTION_CHARS, useStreaming, useStreamingCore };

package/dist/XMarkdown/composables/useTypewriter.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { TypewriterConfig } from '../interface';
+export declare const alignToClusterFallback: (text: string, length: number) => number;
+/**
+ * Never cut inside a user-perceived character: a cut is moved forward to the
+ * next grapheme-cluster boundary so an emoji, a flag or an accented letter
+ * is never shown half-built (or as a replacement glyph) for a frame.
+ */
+export declare const alignToGrapheme: (text: string, length: number) => number;
+export declare function useTypewriter(input: Ref<string>, typewriter: Ref<boolean | TypewriterConfig | undefined>, active: Ref<boolean>): Ref<string>;
+export default useTypewriter;