stream-markdown-parser 0.0.65 → 0.0.67

package/dist/index.js

@@ -601,7 +601,7 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.4/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.5/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
 var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM(require_markdown_it_task_checkbox(), 1);
 var __defProp = Object.defineProperty;
 var __export = (all) => {
@@ -2187,7 +2187,7 @@ var require_punycode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pu
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.4/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.5/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -2199,6 +2199,7 @@ var utils_exports = /* @__PURE__ */ __export({
 	has: () => has,
 	isMdAsciiPunct: () => isMdAsciiPunct,
 	isPunctChar: () => isPunctChar,
+	isPunctCode: () => isPunctCode,
 	isSpace: () => isSpace$7,
 	isString: () => isString,
 	isValidEntityCode: () => isValidEntityCode$1,
@@ -2253,6 +2254,15 @@ function isWhiteSpace(code$1) {
 function isPunctChar(ch) {
 	return regex_default$3.test(ch) || regex_default$5.test(ch);
 }
+const PUNCT_CHAR_CACHE = /* @__PURE__ */ new Map();
+function isPunctCode(ch) {
+	if (isMdAsciiPunct(ch)) return true;
+	const cached = PUNCT_CHAR_CACHE.get(ch);
+	if (cached !== void 0) return cached;
+	const value = isPunctChar(String.fromCharCode(ch));
+	PUNCT_CHAR_CACHE.set(ch, value);
+	return value;
+}
 function isMdAsciiPunct(ch) {
 	switch (ch) {
 		case 33:
@@ -2780,12 +2790,31 @@ function inline(state) {
 		}
 	}
 }
+const CJK_CHAR_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const ASCII_DOMAIN_START_RE = /[0-9a-z]/i;
 function isLinkOpen$1(str) {
 	return /^<a[>\s]/i.test(str);
 }
 function isLinkClose$1(str) {
 	return /^<\/a\s*>/i.test(str);
 }
+function trimCjkPrefixFromFuzzyLink(linkify$2, link$1) {
+	if (link$1.schema || link$1.index !== 0 || !link$1.raw) return link$1;
+	for (let offset = 1; offset < link$1.raw.length; offset++) {
+		const prevChar = link$1.raw[offset - 1];
+		const nextChar = link$1.raw[offset];
+		if (!CJK_CHAR_RE.test(prevChar) || !ASCII_DOMAIN_START_RE.test(nextChar)) continue;
+		const suffix = link$1.raw.slice(offset);
+		const candidate = linkify$2.match(suffix)?.[0];
+		if (!candidate || candidate.index !== 0 || candidate.lastIndex !== suffix.length) continue;
+		return {
+			...candidate,
+			index: link$1.index + offset,
+			lastIndex: link$1.index + offset + candidate.lastIndex
+		};
+	}
+	return link$1;
+}
 function linkify(state) {
 	const blockTokens = state.tokens;
 	if (!state.md?.options?.linkify) return;
@@ -2812,7 +2841,7 @@ function linkify(state) {
 			if (htmlLinkLevel > 0) continue;
 			if (currentToken.type !== "text" || !state.md.linkify.test(currentToken.content)) continue;
 			const text$1 = currentToken.content;
-			let links = state.md.linkify.match(text$1) || [];
+			let links = (state.md.linkify.match(text$1) || []).map((link$1) => trimCjkPrefixFromFuzzyLink(state.md.linkify, link$1));
 			if (links.length === 0) continue;
 			const nodes = [];
 			let level = currentToken.level;
@@ -3121,26 +3150,23 @@ function smartquotes(state) {
 	}
 }
 function text_join(state) {
-	(state.tokens || []).forEach((tk) => {
-		if (tk.type === "inline" && Array.isArray(tk.children)) {
-			const out = [];
-			for (let i = 0; i < tk.children.length; i++) {
-				const ch = tk.children[i];
-				if (ch.type === "text") {
-					let content = ch.content || "";
-					while (i + 1 < tk.children.length && tk.children[i + 1].type === "text") {
-						i++;
-						content += tk.children[i].content || "";
-					}
-					const textToken$1 = new Token("text", "", 0);
-					textToken$1.content = content;
-					textToken$1.level = ch.level;
-					out.push(textToken$1);
-				} else out.push(ch);
-			}
-			tk.children = out;
+	const blockTokens = state.tokens || [];
+	const length = blockTokens.length;
+	for (let j = 0; j < length; j++) {
+		const blockToken = blockTokens[j];
+		if (blockToken.type !== "inline" || !Array.isArray(blockToken.children)) continue;
+		const tokens = blockToken.children;
+		const max = tokens.length;
+		for (let curr$1 = 0; curr$1 < max; curr$1++) if (tokens[curr$1].type === "text_special") tokens[curr$1].type = "text";
+		let last = 0;
+		let curr = 0;
+		for (; curr < max; curr++) if (tokens[curr].type === "text" && curr + 1 < max && tokens[curr + 1].type === "text") tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;
+		else {
+			if (curr !== last) tokens[last] = tokens[curr];
+			last++;
 		}
-	});
+		if (curr !== last) tokens.length = last;
+	}
 }
 function isSpace$6(code$1) {
 	switch (code$1) {
@@ -5271,7 +5297,6 @@ var StateInline = class {
 		token.content = this.pending;
 		token.level = this.pendingLevel;
 		this.tokens.push(token);
-		this.tokens_meta.push(null);
 		this.pending = "";
 		return token;
 	}
@@ -5281,7 +5306,6 @@ var StateInline = class {
 	push(type, tag, nesting) {
 		if (this.pending) this.pushPending();
 		const token = new Token(type, tag, nesting);
-		token.level = this.level;
 		let token_meta = null;
 		if (nesting < 0) {
 			this.level--;
@@ -5308,13 +5332,12 @@ var StateInline = class {
 		let pos = start;
 		while (pos < posMax && src.charCodeAt(pos) === marker) pos++;
 		const count = pos - start;
-		if (count < 1) return null;
 		const lastChar = start > 0 ? src.charCodeAt(start - 1) : 32;
 		const nextChar = pos < posMax ? src.charCodeAt(pos) : 32;
-		const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
-		const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
 		const isLastWhiteSpace = isWhiteSpace(lastChar);
 		const isNextWhiteSpace = isWhiteSpace(nextChar);
+		const isLastPunctChar = isPunctCode(lastChar);
+		const isNextPunctChar = isPunctCode(nextChar);
 		const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
 		const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
 		return {
@@ -5506,8 +5529,7 @@ var ParserCore = class {
 		return new State(src, this.resolveParser(md), env);
 	}
 	process(state) {
-		if (!this.cachedCoreRules) this.cachedCoreRules = this.ruler.getRules("");
-		const rules = this.cachedCoreRules;
+		const rules = this.cachedCoreRules ?? (this.cachedCoreRules = this.ruler.getRules(""));
 		for (let i = 0; i < rules.length; i++) rules[i](state);
 	}
 	parse(src, env = {}, md) {
@@ -5617,21 +5639,64 @@ function ensureSyncResult(value, ruleName) {
 	return value;
 }
 const resolveResult = (value) => isPromiseLike(value) ? value : Promise.resolve(value);
+function parseFenceInfo(info) {
+	if (!info) return {
+		langName: "",
+		langAttrs: ""
+	};
+	let markerEnd = 0;
+	while (markerEnd < info.length) {
+		const ch = info.charCodeAt(markerEnd);
+		if (ch === 32 || ch === 9 || ch === 10) break;
+		markerEnd++;
+	}
+	if (markerEnd >= info.length) return {
+		langName: info,
+		langAttrs: ""
+	};
+	let attrsStart = markerEnd;
+	while (attrsStart < info.length) {
+		const ch = info.charCodeAt(attrsStart);
+		if (ch !== 32 && ch !== 9 && ch !== 10) break;
+		attrsStart++;
+	}
+	return {
+		langName: info.slice(0, markerEnd),
+		langAttrs: attrsStart < info.length ? info.slice(attrsStart) : ""
+	};
+}
 function renderFence(token, highlighted, info, langName, options, self) {
 	if (highlighted.startsWith("<pre")) return `${highlighted}\n`;
 	if (info) {
-		const classIndex = typeof token.attrIndex === "function" ? token.attrIndex("class") : -1;
-		const tmpAttrs = token.attrs ? token.attrs.map((attr) => attr.slice()) : [];
+		const classIndex = token.attrIndex("class");
+		const tmpAttrs = token.attrs ? token.attrs.slice() : [];
 		const langClass = `${options.langPrefix || "language-"}${langName}`;
 		if (classIndex < 0) tmpAttrs.push(["class", langClass]);
-		else tmpAttrs[classIndex][1] += ` ${langClass}`;
+		else tmpAttrs[classIndex] = tmpAttrs[classIndex].slice();
+		if (classIndex >= 0) tmpAttrs[classIndex][1] += ` ${langClass}`;
 		const tmpToken = {
 			...token,
 			attrs: tmpAttrs
 		};
-		return `<pre><code${self.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`;
+		return `<pre><code${tmpAttrs.length > 0 ? self.renderAttrs(tmpToken) : ""}>${highlighted}</code></pre>\n`;
 	}
-	return `<pre><code${self.renderAttrs(token)}>${highlighted}</code></pre>\n`;
+	return `<pre><code${token.attrs && token.attrs.length > 0 ? self.renderAttrs(token) : ""}>${highlighted}</code></pre>\n`;
+}
+function renderCodeInlineToken(token, self) {
+	return `<code${token.attrs && token.attrs.length > 0 ? self.renderAttrs(token) : ""}>${escapeHtml(token.content)}</code>`;
+}
+function renderCodeBlockToken(token, self) {
+	return `<pre${token.attrs && token.attrs.length > 0 ? self.renderAttrs(token) : ""}><code>${escapeHtml(token.content)}</code></pre>\n`;
+}
+function renderFenceSyncToken(token, options, self) {
+	const info = token.info ? unescapeAll(token.info).trim() : "";
+	const { langName, langAttrs } = parseFenceInfo(info);
+	const highlight = options.highlight;
+	const fallback = escapeHtml(token.content);
+	if (!highlight) return renderFence(token, fallback, info, langName, options, self);
+	const highlighted = highlight(token.content, langName, langAttrs);
+	if (isPromiseLike(highlighted)) throw new TypeError("Renderer rule \"fence\" returned a Promise. Use renderAsync() instead.");
+	return renderFence(token, highlighted || fallback, info, langName, options, self);
 }
 const DEFAULT_RENDERER_OPTIONS = {
 	langPrefix: "language-",
@@ -5641,39 +5706,29 @@ const DEFAULT_RENDERER_OPTIONS = {
 const hasOwn = Object.prototype.hasOwnProperty;
 const defaultRules = {
 	code_inline(tokens, idx, _options, _env, self) {
-		const token = tokens[idx];
-		return `<code${self.renderAttrs(token)}>${escapeHtml(token.content)}</code>`;
+		return renderCodeInlineToken(tokens[idx], self);
 	},
 	code_block(tokens, idx, _options, _env, self) {
-		const token = tokens[idx];
-		return `<pre${self.renderAttrs(token)}><code>${escapeHtml(token.content)}</code></pre>\n`;
+		return renderCodeBlockToken(tokens[idx], self);
 	},
 	fence(tokens, idx, options, _env, self) {
 		const token = tokens[idx];
 		const info = token.info ? unescapeAll(token.info).trim() : "";
-		let langName = "";
-		let langAttrs = "";
-		if (info) {
-			const parts = info.split(/(\s+)/g);
-			langName = parts[0];
-			langAttrs = parts.slice(2).join("");
-		}
+		const { langName, langAttrs } = parseFenceInfo(info);
 		const highlight = options.highlight;
-		const fallback = () => escapeHtml(token.content);
-		if (!highlight) return renderFence(token, fallback(), info, langName, options, self);
+		const fallback = escapeHtml(token.content);
+		if (!highlight) return renderFence(token, fallback, info, langName, options, self);
 		const highlighted = highlight(token.content, langName, langAttrs);
-		if (isPromiseLike(highlighted)) return highlighted.then((res) => renderFence(token, res || fallback(), info, langName, options, self));
-		return renderFence(token, highlighted || fallback(), info, langName, options, self);
+		if (isPromiseLike(highlighted)) return highlighted.then((res) => renderFence(token, res || fallback, info, langName, options, self));
+		return renderFence(token, highlighted || fallback, info, langName, options, self);
 	},
 	image(tokens, idx, options, env, self) {
 		const token = tokens[idx];
 		const altText = self.renderInlineAsText(token.children || [], options, env);
-		if (typeof token.attrIndex === "function") {
-			const altIndex = token.attrIndex("alt");
-			if (altIndex >= 0 && token.attrs) token.attrs[altIndex][1] = altText;
-			else if (token.attrs) token.attrs.push(["alt", altText]);
-			else token.attrs = [["alt", altText]];
-		}
+		const altIndex = token.attrIndex("alt");
+		if (altIndex >= 0 && token.attrs) token.attrs[altIndex][1] = altText;
+		else if (token.attrs) token.attrs.push(["alt", altText]);
+		else token.attrs = [["alt", altText]];
 		return self.renderToken(tokens, idx, options);
 	},
 	hardbreak(_tokens, _idx, options) {
@@ -5717,36 +5772,65 @@ var Renderer = class {
 		const merged = this.mergeOptions(options);
 		const envRef = env ?? {};
 		const rules = this.rules;
-		const out = new Array(tokens.length);
+		const codeBlockRule = rules.code_block;
+		const fenceRule = rules.fence;
+		const htmlBlockRule = rules.html_block;
+		let result = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				out[i] = this.renderInlineTokens(token.children || [], merged, envRef);
+				result += this.renderInlineTokens(token.children || [], merged, envRef);
 				continue;
 			}
+			switch (token.type) {
+				case "code_block":
+					if (codeBlockRule === defaultRules.code_block) {
+						result += renderCodeBlockToken(token, this);
+						continue;
+					}
+					break;
+				case "fence":
+					if (fenceRule === defaultRules.fence) {
+						result += renderFenceSyncToken(token, merged, this);
+						continue;
+					}
+					break;
+				case "html_block":
+					if (htmlBlockRule === defaultRules.html_block) {
+						result += token.content;
+						continue;
+					}
+					break;
+				default: break;
+			}
 			const rule = rules[token.type];
-			if (rule) out[i] = ensureSyncResult(rule(tokens, i, merged, envRef, this), token.type);
-			else out[i] = this.renderToken(tokens, i, merged);
+			if (!rule) {
+				result += this.renderToken(tokens, i, merged);
+				continue;
+			}
+			const rendered = rule(tokens, i, merged, envRef, this);
+			if (typeof rendered === "string") result += rendered;
+			else result += ensureSyncResult(rendered, token.type);
 		}
-		return out.join("");
+		return result;
 	}
 	async renderAsync(tokens, options, env) {
 		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
 		const merged = this.mergeOptions(options);
 		const envRef = env ?? {};
 		const rules = this.rules;
-		const out = new Array(tokens.length);
+		let result = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				out[i] = await this.renderInlineTokensAsync(token.children || [], merged, envRef);
+				result += await this.renderInlineTokensAsync(token.children || [], merged, envRef);
 				continue;
 			}
 			const rule = rules[token.type];
-			if (rule) out[i] = await resolveResult(rule(tokens, i, merged, envRef, this));
-			else out[i] = this.renderToken(tokens, i, merged);
+			if (rule) result += await resolveResult(rule(tokens, i, merged, envRef, this));
+			else result += this.renderToken(tokens, i, merged);
 		}
-		return out.join("");
+		return result;
 	}
 	renderInline(tokens, options, env) {
 		const merged = this.mergeOptions(options);
@@ -5778,7 +5862,7 @@ var Renderer = class {
 		let result = "";
 		if (token.block && token.nesting !== -1 && idx > 0 && tokens[idx - 1].hidden) result += "\n";
 		result += token.nesting === -1 ? `</${token.tag}` : `<${token.tag}`;
-		result += this.renderAttrs(token);
+		if (token.attrs && token.attrs.length > 0) result += this.renderAttrs(token);
 		if (token.nesting === 0 && options.xhtmlOut) result += " /";
 		let needLineFeed = false;
 		if (token.block) {
@@ -5824,25 +5908,77 @@ var Renderer = class {
 	renderInlineTokens(tokens, options, env) {
 		if (!tokens || tokens.length === 0) return "";
 		const rules = this.rules;
-		const out = new Array(tokens.length);
+		const textRule = rules.text;
+		const textSpecialRule = rules.text_special;
+		const softbreakRule = rules.softbreak;
+		const hardbreakRule = rules.hardbreak;
+		const htmlInlineRule = rules.html_inline;
+		const codeInlineRule = rules.code_inline;
+		const inlineBreak = options.xhtmlOut ? "<br />\n" : "<br>\n";
+		const softbreak = options.breaks ? inlineBreak : "\n";
+		let result = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
+			switch (token.type) {
+				case "text":
+					if (textRule === defaultRules.text) {
+						result += escapeHtml(token.content);
+						continue;
+					}
+					break;
+				case "text_special":
+					if (textSpecialRule === defaultRules.text_special) {
+						result += escapeHtml(token.content);
+						continue;
+					}
+					break;
+				case "softbreak":
+					if (softbreakRule === defaultRules.softbreak) {
+						result += softbreak;
+						continue;
+					}
+					break;
+				case "hardbreak":
+					if (hardbreakRule === defaultRules.hardbreak) {
+						result += inlineBreak;
+						continue;
+					}
+					break;
+				case "html_inline":
+					if (htmlInlineRule === defaultRules.html_inline) {
+						result += token.content;
+						continue;
+					}
+					break;
+				case "code_inline":
+					if (codeInlineRule === defaultRules.code_inline) {
+						result += renderCodeInlineToken(token, this);
+						continue;
+					}
+					break;
+				default: break;
+			}
 			const rule = rules[token.type];
-			if (rule) out[i] = ensureSyncResult(rule(tokens, i, options, env, this), token.type);
-			else out[i] = this.renderToken(tokens, i, options);
+			if (!rule) {
+				result += this.renderToken(tokens, i, options);
+				continue;
+			}
+			const rendered = rule(tokens, i, options, env, this);
+			if (typeof rendered === "string") result += rendered;
+			else result += ensureSyncResult(rendered, token.type);
 		}
-		return out.join("");
+		return result;
 	}
 	async renderInlineTokensAsync(tokens, options, env) {
 		if (!tokens || tokens.length === 0) return "";
 		const rules = this.rules;
-		const out = new Array(tokens.length);
+		let result = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const rule = rules[tokens[i].type];
-			if (rule) out[i] = await resolveResult(rule(tokens, i, options, env, this));
-			else out[i] = this.renderToken(tokens, i, options);
+			if (rule) result += await resolveResult(rule(tokens, i, options, env, this));
+			else result += this.renderToken(tokens, i, options);
 		}
-		return out.join("");
+		return result;
 	}
 	renderInlineAsTextInternal(tokens, options, env) {
 		if (!tokens || tokens.length === 0) return "";
@@ -5999,6 +6135,7 @@ function makeEmptyStats() {
 		total: 0,
 		cacheHits: 0,
 		appendHits: 0,
+		tailHits: 0,
 		fullParses: 0,
 		resets: 0,
 		chunkedParses: 0,
@@ -6014,6 +6151,10 @@ var StreamParser = class {
 	DEFAULT_SKIP_CACHE_LINES = 1e4;
 	MAX_CHUNKS_FOR_FALLBACK = 24;
 	MAX_CHUNKED_DOC_CHARS = 12e4;
+	MIN_LIST_LINES_FOR_MERGE = 80;
+	MIN_LIST_CHARS_FOR_MERGE = 800;
+	MIN_TABLE_LINES_FOR_MERGE = 48;
+	MIN_TABLE_CHARS_FOR_MERGE = 1200;
 	constructor(core) {
 		this.core = core;
 	}
@@ -6086,8 +6227,10 @@ var StreamParser = class {
 						src,
 						tokens: tokens$1,
 						env: workingEnv,
-						lineCount: srcLineCount
+						lineCount: srcLineCount,
+						lastSegment: void 0
 					};
+					this.updateCacheLineCount(this.cache, srcLineCount);
 					this.stats.total += 1;
 					this.stats.chunkedParses = (this.stats.chunkedParses || 0) + 1;
 					this.stats.lastMode = "chunked";
@@ -6099,8 +6242,10 @@ var StreamParser = class {
 				src,
 				tokens,
 				env: workingEnv,
-				lineCount: srcLineCount
+				lineCount: srcLineCount,
+				lastSegment: void 0
 			};
+			this.updateCacheLineCount(this.cache, srcLineCount);
 			this.stats.total += 1;
 			this.stats.fullParses += 1;
 			this.stats.lastMode = "full";
@@ -6116,19 +6261,22 @@ var StreamParser = class {
 		if (cached.src.length < threshold && src.length < threshold * 1.5 && !src.startsWith(cached.src)) {
 			const fallbackEnv$1 = envProvided ?? cached.env;
 			const nextTokens$1 = this.core.parse(src, fallbackEnv$1, md).tokens;
+			const lineCount = countLines(src);
 			this.cache = {
 				src,
 				tokens: nextTokens$1,
 				env: fallbackEnv$1,
-				lineCount: countLines(src)
+				lineCount,
+				lastSegment: void 0
 			};
+			this.updateCacheLineCount(this.cache, lineCount);
 			this.stats.total += 1;
 			this.stats.fullParses += 1;
 			this.stats.lastMode = "full";
 			return nextTokens$1;
 		}
 		const appended = this.getAppendedSegment(cached.src, src);
-		if (appended) {
+		if (appended && !this.shouldPreferTailReparseForAppend(cached)) {
 			const cachedLineCount = cached.lineCount ?? countLines(cached.src);
 			let ctxLines = 3;
 			if (appended.length > 5e3) ctxLines = 8;
@@ -6233,8 +6381,9 @@ var StreamParser = class {
 				if (appendedLineCount === null) appendedLineCount = countLines(appended);
 				return appendedLineCount;
 			};
+			const canDirectParseAppend = this.canDirectlyParseAppend(cached);
 			let shouldAttemptContext = false;
-			switch (ctxStrategy) {
+			if (!canDirectParseAppend) switch (ctxStrategy) {
 				case "lines":
 					shouldAttemptContext = getAppendedLineCount() >= CONTEXT_PARSE_MIN_LINES;
 					break;
@@ -6287,6 +6436,7 @@ var StreamParser = class {
 					}
 				} catch {}
 			}
+			const appendStart = cached.tokens.length;
 			if (appendedState.tokens.length > 0) {
 				const cachedTail = cached.tokens;
 				const a = appendedState.tokens;
@@ -6318,12 +6468,30 @@ var StreamParser = class {
 			}
 			cached.src = src;
 			cached.lineCount = cachedLineCount + (appendedLineCount ?? countLines(appended));
+			if (cached.tokens.length > appendStart) {
+				const appendedLastSegment = this.getLastSegment(cached.tokens.slice(appendStart), src);
+				if (appendedLastSegment) cached.lastSegment = {
+					tokenStart: appendStart + appendedLastSegment.tokenStart,
+					tokenEnd: appendStart + appendedLastSegment.tokenEnd,
+					lineStart: appendedLastSegment.lineStart,
+					lineEnd: appendedLastSegment.lineEnd,
+					srcOffset: appendedLastSegment.srcOffset
+				};
+				else cached.lastSegment = void 0;
+			} else cached.lastSegment = void 0;
 			this.stats.total += 1;
 			this.stats.appendHits += 1;
 			this.stats.lastMode = "append";
 			return cached.tokens;
 		}
 		const fallbackEnv = envProvided ?? cached.env;
+		const tailReparsed = this.tryTailSegmentReparse(src, cached, fallbackEnv, md);
+		if (tailReparsed) {
+			this.stats.total += 1;
+			this.stats.tailHits += 1;
+			this.stats.lastMode = "tail";
+			return tailReparsed;
+		}
 		const chunkedEnabled = !!md.options?.streamChunkedFallback;
 		const chunkAdaptive = md.options?.streamChunkAdaptive !== false;
 		const targetChunks = md.options?.streamChunkTargetChunks ?? 8;
@@ -6365,8 +6533,10 @@ var StreamParser = class {
 					src,
 					tokens,
 					env: fallbackEnv,
-					lineCount: srcLineCount2
+					lineCount: srcLineCount2,
+					lastSegment: void 0
 				};
+				this.updateCacheLineCount(this.cache, srcLineCount2);
 				this.stats.total += 1;
 				this.stats.chunkedParses = (this.stats.chunkedParses || 0) + 1;
 				this.stats.lastMode = "chunked";
@@ -6378,8 +6548,10 @@ var StreamParser = class {
 			src,
 			tokens: nextTokens,
 			env: fallbackEnv,
-			lineCount: srcLineCount2
+			lineCount: srcLineCount2,
+			lastSegment: void 0
 		};
+		this.updateCacheLineCount(this.cache, srcLineCount2);
 		this.stats.total += 1;
 		this.stats.fullParses += 1;
 		this.stats.lastMode = "full";
@@ -6408,8 +6580,46 @@ var StreamParser = class {
 			if (prevWithoutTrailingNewline.slice(lastBreak + 1).trim().length > 0) return null;
 		}
 		if (this.endsInsideOpenFence(prev)) return null;
+		if (this.mayContainReferenceDefinition(segment)) return null;
 		return segment;
 	}
+	tryTailSegmentReparse(src, cached, env, md) {
+		const lastSegment = this.ensureLastSegment(cached);
+		if (!lastSegment) return null;
+		if (lastSegment.srcOffset <= 0 && lastSegment.tokenStart <= 0) return null;
+		const stablePrefix = cached.src.slice(0, lastSegment.srcOffset);
+		if (!src.startsWith(stablePrefix)) return null;
+		const prevTail = cached.src.slice(lastSegment.srcOffset);
+		const nextTail = src.slice(lastSegment.srcOffset);
+		if (nextTail === prevTail) return null;
+		const appended = src.startsWith(cached.src) ? src.slice(cached.src.length) : null;
+		if (appended) {
+			const merged = this.tryContainerTailAppendMerge(src, cached, env, md, lastSegment, appended);
+			if (merged) return merged;
+		}
+		if (this.mayContainReferenceDefinition(prevTail) || this.mayContainReferenceDefinition(nextTail)) return null;
+		try {
+			const tailState = this.core.parse(nextTail, env, md);
+			const localLastSegment = this.getLastSegment(tailState.tokens, nextTail);
+			if (lastSegment.lineStart > 0) this.shiftTokenLines(tailState.tokens, lastSegment.lineStart);
+			cached.src = src;
+			cached.env = env;
+			cached.tokens.length = lastSegment.tokenStart;
+			cached.tokens.push(...tailState.tokens);
+			cached.lineCount = countLines(src);
+			if (localLastSegment) cached.lastSegment = {
+				tokenStart: lastSegment.tokenStart + localLastSegment.tokenStart,
+				tokenEnd: lastSegment.tokenStart + localLastSegment.tokenEnd,
+				lineStart: lastSegment.lineStart + localLastSegment.lineStart,
+				lineEnd: lastSegment.lineStart + localLastSegment.lineEnd,
+				srcOffset: lastSegment.srcOffset + localLastSegment.srcOffset
+			};
+			else cached.lastSegment = null;
+			return cached.tokens;
+		} catch {
+			return null;
+		}
+	}
 	getTailLines(src, lineCount) {
 		if (lineCount <= 0) return "";
 		let remaining = lineCount;
@@ -6461,6 +6671,293 @@ var StreamParser = class {
 	getStats() {
 		return { ...this.stats };
 	}
+	updateCacheLineCount(cache, lineCount) {
+		cache.lineCount = lineCount ?? countLines(cache.src);
+		cache.lastSegment = void 0;
+	}
+	ensureLastSegment(cache) {
+		if (cache.lastSegment !== void 0) return cache.lastSegment;
+		cache.lastSegment = this.getLastSegment(cache.tokens, cache.src);
+		return cache.lastSegment;
+	}
+	getLastSegment(tokens, src) {
+		if (tokens.length === 0) return null;
+		let lineStart = Number.POSITIVE_INFINITY;
+		let lineEnd = -1;
+		let depth = 0;
+		for (let i = tokens.length - 1; i >= 0; i--) {
+			const token = tokens[i];
+			if (token.map) {
+				if (token.map[0] < lineStart) lineStart = token.map[0];
+				if (token.map[1] > lineEnd) lineEnd = token.map[1];
+			}
+			if (token.nesting < 0) {
+				depth += -token.nesting;
+				continue;
+			}
+			if (token.nesting > 0) {
+				depth -= token.nesting;
+				if (token.level === 0 && depth <= 0) {
+					const resolvedStart = Number.isFinite(lineStart) ? lineStart : token.map?.[0] ?? 0;
+					const resolvedEnd = lineEnd >= resolvedStart ? lineEnd : token.map?.[1] ?? resolvedStart;
+					return {
+						tokenStart: i,
+						tokenEnd: tokens.length,
+						lineStart: resolvedStart,
+						lineEnd: resolvedEnd,
+						srcOffset: this.getLineStartOffset(src, resolvedStart)
+					};
+				}
+				continue;
+			}
+			if (token.level === 0 && depth === 0) {
+				const resolvedStart = Number.isFinite(lineStart) ? lineStart : token.map?.[0] ?? 0;
+				const resolvedEnd = lineEnd >= resolvedStart ? lineEnd : token.map?.[1] ?? resolvedStart;
+				return {
+					tokenStart: i,
+					tokenEnd: tokens.length,
+					lineStart: resolvedStart,
+					lineEnd: resolvedEnd,
+					srcOffset: this.getLineStartOffset(src, resolvedStart)
+				};
+			}
+		}
+		return null;
+	}
+	getLineStartOffset(src, line) {
+		if (line <= 0) return 0;
+		let remaining = line;
+		let pos = -1;
+		while (remaining > 0) {
+			pos = src.indexOf("\n", pos + 1);
+			if (pos === -1) return src.length;
+			remaining--;
+		}
+		return pos + 1;
+	}
+	mayContainReferenceDefinition(src) {
+		if (!src.includes("]:")) return false;
+		return /(?:^|\n)[ \t]{0,3}\[[^\]\n]+\]:/.test(src);
+	}
+	canDirectlyParseAppend(cache) {
+		if (!this.endsWithBlankLine(cache.src)) return false;
+		const lastSegment = this.ensureLastSegment(cache);
+		if (!lastSegment) return false;
+		switch (cache.tokens[lastSegment.tokenStart]?.type) {
+			case "paragraph_open":
+			case "heading_open":
+			case "fence":
+			case "code_block":
+			case "html_block":
+			case "hr":
+			case "table_open": return true;
+			default: return false;
+		}
+	}
+	tryContainerTailAppendMerge(src, cached, env, md, lastSegment, appended) {
+		if (!appended || this.mayContainReferenceDefinition(appended)) return null;
+		const lastToken = cached.tokens[lastSegment.tokenStart];
+		switch (lastToken?.type) {
+			case "bullet_list_open":
+			case "ordered_list_open": return this.tryListTailAppendMerge(src, cached, env, md, lastSegment, appended, lastToken);
+			case "table_open": return this.tryTableTailAppendMerge(src, cached, env, md, lastSegment, appended, lastToken);
+			default: return null;
+		}
+	}
+	tryListTailAppendMerge(src, cached, env, md, lastSegment, appended, listOpen) {
+		if (cached.src.length === 0 || cached.src.charCodeAt(cached.src.length - 1) !== 10) return null;
+		const segmentLineSpan = lastSegment.lineEnd - lastSegment.lineStart;
+		const segmentChars = cached.src.length - lastSegment.srcOffset;
+		if (segmentLineSpan < this.MIN_LIST_LINES_FOR_MERGE && segmentChars < this.MIN_LIST_CHARS_FOR_MERGE) return null;
+		const closeType = listOpen.type === "bullet_list_open" ? "bullet_list_close" : "ordered_list_close";
+		let parsed;
+		try {
+			parsed = this.core.parse(appended, env, md).tokens;
+		} catch {
+			return null;
+		}
+		if (!this.isSingleTopLevelContainer(parsed, listOpen.type, closeType, listOpen.markup)) return null;
+		const inserted = parsed.slice(1, -1);
+		if (inserted.length === 0) return null;
+		const lineOffset = cached.lineCount ?? countLines(cached.src);
+		if (lineOffset > 0) this.shiftTokenLines(inserted, lineOffset);
+		const existingMode = this.getListParagraphMode(cached.tokens, lastSegment.tokenStart, cached.tokens.length, listOpen.level);
+		const appendedMode = this.getListParagraphMode(parsed, 0, parsed.length, 0);
+		if (existingMode === "loose" || appendedMode === "loose" || this.endsWithBlankLine(cached.src) || (parsed[0]?.map?.[0] ?? 0) > 0) {
+			this.setListParagraphVisibility(cached.tokens, lastSegment.tokenStart, cached.tokens.length, listOpen.level, false);
+			this.setListParagraphVisibility(inserted, 0, inserted.length, listOpen.level, false);
+		}
+		cached.tokens.splice(cached.tokens.length - 1, 0, ...inserted);
+		cached.src = src;
+		cached.env = env;
+		cached.lineCount = countLines(src);
+		if (listOpen.map) listOpen.map[1] = this.getDocLineCount(src);
+		cached.lastSegment = {
+			tokenStart: lastSegment.tokenStart,
+			tokenEnd: cached.tokens.length,
+			lineStart: lastSegment.lineStart,
+			lineEnd: this.getDocLineCount(src),
+			srcOffset: lastSegment.srcOffset
+		};
+		return cached.tokens;
+	}
+	tryTableTailAppendMerge(src, cached, env, md, lastSegment, appended, tableOpen) {
+		if (cached.src.length === 0 || cached.src.charCodeAt(cached.src.length - 1) !== 10) return null;
+		if (/(?:^|\n)[ \t]*\n/.test(appended)) return null;
+		const segmentLineSpan = lastSegment.lineEnd - lastSegment.lineStart;
+		const segmentChars = cached.src.length - lastSegment.srcOffset;
+		if (segmentLineSpan < this.MIN_TABLE_LINES_FOR_MERGE && segmentChars < this.MIN_TABLE_CHARS_FOR_MERGE) return null;
+		const tableContext = this.getTableHeaderContext(cached.src.slice(lastSegment.srcOffset));
+		if (!tableContext) return null;
+		const syntheticSrc = `${tableContext}${appended}`;
+		let parsed;
+		try {
+			parsed = this.core.parse(syntheticSrc, env, md).tokens;
+		} catch {
+			return null;
+		}
+		if (!this.isSingleTopLevelContainer(parsed, "table_open", "table_close")) return null;
+		if ((parsed[0]?.map?.[1] ?? -1) !== this.getDocLineCount(syntheticSrc)) return null;
+		const parsedSection = this.getTableBodySection(parsed, 0, parsed.length, 0);
+		const cachedSection = this.getTableBodySection(cached.tokens, lastSegment.tokenStart, cached.tokens.length, tableOpen.level);
+		if (!parsedSection || !cachedSection || parsedSection.tbodyOpenIndex < 0 || parsedSection.tbodyCloseIndex < 0) return null;
+		const inserted = cachedSection.tbodyOpenIndex >= 0 ? parsed.slice(parsedSection.tbodyOpenIndex + 1, parsedSection.tbodyCloseIndex) : parsed.slice(parsedSection.tbodyOpenIndex, parsedSection.tbodyCloseIndex + 1);
+		if (inserted.length === 0) return null;
+		const lineOffset = lastSegment.lineEnd - 2;
+		if (lineOffset !== 0) this.shiftTokenLines(inserted, lineOffset);
+		const insertAt = cachedSection.tbodyCloseIndex >= 0 ? cachedSection.tbodyCloseIndex : cachedSection.tableCloseIndex;
+		cached.tokens.splice(insertAt, 0, ...inserted);
+		cached.src = src;
+		cached.env = env;
+		cached.lineCount = countLines(src);
+		const nextDocLineCount = this.getDocLineCount(src);
+		if (tableOpen.map) tableOpen.map[1] = nextDocLineCount;
+		if (cachedSection.tbodyOpenIndex >= 0) {
+			const tbodyOpen = cached.tokens[cachedSection.tbodyOpenIndex];
+			if (tbodyOpen?.map) tbodyOpen.map[1] = nextDocLineCount;
+		}
+		cached.lastSegment = {
+			tokenStart: lastSegment.tokenStart,
+			tokenEnd: cached.tokens.length,
+			lineStart: lastSegment.lineStart,
+			lineEnd: nextDocLineCount,
+			srcOffset: lastSegment.srcOffset
+		};
+		return cached.tokens;
+	}
+	getTableHeaderContext(src) {
+		const firstBreak = src.indexOf("\n");
+		if (firstBreak < 0) return null;
+		const secondBreak = src.indexOf("\n", firstBreak + 1);
+		if (secondBreak < 0) return null;
+		return src.slice(0, secondBreak + 1);
+	}
+	getTableBodySection(tokens, start, end, tableLevel) {
+		if (start < 0 || start >= end || tokens[start]?.type !== "table_open") return null;
+		let tableCloseIndex = -1;
+		for (let i = end - 1; i > start; i--) {
+			const token = tokens[i];
+			if (token.type === "table_close" && token.level === tableLevel) {
+				tableCloseIndex = i;
+				break;
+			}
+		}
+		if (tableCloseIndex < 0) return null;
+		let tbodyOpenIndex = -1;
+		let tbodyCloseIndex = -1;
+		for (let i = start + 1; i < tableCloseIndex; i++) {
+			const token = tokens[i];
+			if (token.type === "tbody_open" && token.level === tableLevel + 1) {
+				tbodyOpenIndex = i;
+				break;
+			}
+		}
+		if (tbodyOpenIndex >= 0) {
+			for (let i = tableCloseIndex - 1; i > tbodyOpenIndex; i--) {
+				const token = tokens[i];
+				if (token.type === "tbody_close" && token.level === tableLevel + 1) {
+					tbodyCloseIndex = i;
+					break;
+				}
+			}
+			if (tbodyCloseIndex < 0) return null;
+		}
+		return {
+			tableCloseIndex,
+			tbodyOpenIndex,
+			tbodyCloseIndex
+		};
+	}
+	isSingleTopLevelContainer(tokens, openType, closeType, markup) {
+		if (tokens.length < 2) return false;
+		const first = tokens[0];
+		const last = tokens[tokens.length - 1];
+		if (first.type !== openType || last.type !== closeType || first.level !== 0 || last.level !== 0) return false;
+		if (markup !== void 0 && first.markup !== markup) return false;
+		let depth = 0;
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (token.level === 0 && i > 0 && i < tokens.length - 1 && depth === 0) return false;
+			if (token.nesting > 0) depth += token.nesting;
+			else if (token.nesting < 0) depth += token.nesting;
+		}
+		return depth === 0;
+	}
+	getListParagraphMode(tokens, start, end, listLevel) {
+		let sawHidden = false;
+		let sawVisible = false;
+		const paragraphLevel = listLevel + 2;
+		for (let i = start; i < end; i++) {
+			const token = tokens[i];
+			if (token.type !== "paragraph_open" || token.level !== paragraphLevel) continue;
+			if (token.hidden) sawHidden = true;
+			else sawVisible = true;
+			if (sawHidden && sawVisible) return "loose";
+		}
+		if (sawVisible) return "loose";
+		if (sawHidden) return "tight";
+		return "none";
+	}
+	setListParagraphVisibility(tokens, start, end, listLevel, hidden) {
+		const paragraphLevel = listLevel + 2;
+		for (let i = start; i < end; i++) {
+			const token = tokens[i];
+			if ((token.type === "paragraph_open" || token.type === "paragraph_close") && token.level === paragraphLevel) token.hidden = hidden;
+		}
+	}
+	shouldPreferTailReparseForAppend(cache) {
+		const lastSegment = this.ensureLastSegment(cache);
+		if (!lastSegment) return false;
+		switch (cache.tokens[lastSegment.tokenStart]?.type) {
+			case "bullet_list_open":
+			case "ordered_list_open":
+			case "blockquote_open":
+			case "table_open": return true;
+			case "paragraph_open":
+			case "code_block":
+			case "html_block": return !this.endsWithBlankLine(cache.src);
+			default: return false;
+		}
+	}
+	endsWithBlankLine(src) {
+		const len = src.length;
+		if (len < 2 || src.charCodeAt(len - 1) !== 10) return false;
+		let pos = len - 2;
+		while (pos >= 0) {
+			const ch = src.charCodeAt(pos);
+			if (ch === 32 || ch === 9) {
+				pos--;
+				continue;
+			}
+			return ch === 10;
+		}
+		return true;
+	}
+	getDocLineCount(src) {
+		const lines = countLines(src);
+		if (src.length === 0) return 0;
+		return src.charCodeAt(src.length - 1) === 10 ? lines : lines + 1;
+	}
 	shiftTokenLines(tokens, offset) {
 		if (offset === 0) return;
 		const stack = [...tokens];
@@ -6746,6 +7243,7 @@ function markdownIt(presetName, options) {
 				total: 0,
 				cacheHits: 0,
 				appendHits: 0,
+				tailHits: 0,
 				fullParses: 0,
 				resets: 0,
 				chunkedParses: 0,
@@ -10247,6 +10745,7 @@ function parseTextToken(token) {
 const STRONG_PAIR_RE = /\*\*([\s\S]*?)\*\*/;
 const STRIKETHROUGH_RE = /[^~]*~{2,}[^~]+/;
 const HAS_STRONG_RE = /\*\*/;
+const ESCAPED_PUNCTUATION_RE = /\\([\\()[\]`$|*_\-!])/g;
 function countUnescapedAsterisks(str) {
 	let count = 0;
 	let i = 0;
@@ -10597,6 +11096,17 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 			result.push(currentTextNode);
 		}
 	}
+	function hasEscapedMarkup(token, escapedPrefix) {
+		return String(token.markup ?? "").startsWith(escapedPrefix);
+	}
+	function stripTrailingMidStateMarker(content, token) {
+		let nextContent = content;
+		const rawTokenContent = String(token.content ?? "");
+		if (nextContent.endsWith("\\") && !hasEscapedMarkup(token, "\\\\") && !rawTokenContent.endsWith("\\\\")) nextContent = nextContent.slice(0, -1);
+		if (nextContent.endsWith("(") && !hasEscapedMarkup(token, "\\(") && !rawTokenContent.endsWith("\\(")) nextContent = nextContent.slice(0, -1);
+		if (/\*+$/.test(nextContent) && !hasEscapedMarkup(token, "\\*") && !rawTokenContent.endsWith("\\*")) nextContent = nextContent.replace(/\*+$/, "");
+		return nextContent;
+	}
 	while (i < tokens.length) {
 		const token = tokens[i];
 		handleToken(token);
@@ -10791,12 +11301,12 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 			content
 		});
 		if (currentTextNode) {
-			currentTextNode.content += textNode.content.replace(/(\*+|\(|\\)$/, "");
+			currentTextNode.content += stripTrailingMidStateMarker(textNode.content, token);
 			currentTextNode.raw += textNode.raw;
 			return;
 		}
 		const maybeMath = preToken?.tag === "br" && tokens[i - 2]?.content === "[";
-		if (!nextToken) textNode.content = textNode.content.replace(/(\*+|\(|\\)$/, "");
+		if (!nextToken) textNode.content = stripTrailingMidStateMarker(textNode.content, token);
 		currentTextNode = textNode;
 		currentTextNode.center = maybeMath;
 		result.push(currentTextNode);
@@ -10804,8 +11314,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 	function handleTextToken(token) {
 		let index = result.length - 1;
 		const rawContent = String(token.content ?? "");
-		let content = rawContent;
-		if (rawContent.includes("\\")) content = rawContent.replace(/\\/g, "");
+		let content = rawContent.replace(ESCAPED_PUNCTUATION_RE, "$1");
 		if (token.content === "<" || content === "1" && tokens[i - 1]?.tag === "br") {
 			i++;
 			return;
@@ -10829,7 +11338,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 			i++;
 			return;
 		}
-		if (content === "`" || content === "|" || content === "$" || /^\*+$/.test(content)) {
+		if ((content === "`" || content === "|" || content === "$") && !hasEscapedMarkup(token, `\\${content}`) || /^\*+$/.test(content) && !hasEscapedMarkup(token, "\\*")) {
 			i++;
 			return;
 		}