stream-markdown-parser 1.0.2 → 1.0.5

package/dist/index.js

@@ -10193,7 +10193,14 @@ const NON_STRUCTURING_HTML_TAG_NAMES = [
 	"pre",
 	"script",
 	"style",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
 	"textarea",
+	"tr",
 	"title"
 ];
 const VOID_HTML_TAGS = new Set(VOID_HTML_TAG_NAMES);
@@ -12712,6 +12719,16 @@ function isMathLike(s) {
 
 //#endregion
 //#region src/plugins/math.ts
+const MARKSTREAM_MATH_PLUGIN_APPLIED = "__markstreamMathPluginApplied";
+const TOLERANT_BOUNDARY_SCAN_MAX_LINES = 80;
+const TOLERANT_BOUNDARY_SCAN_MAX_CHARS = 2e4;
+const TOLERANT_BOUNDARY_SCAN_TAIL_CHARS = TOLERANT_BOUNDARY_SCAN_MAX_CHARS + 4096;
+function hasMarkstreamMathPlugin(md) {
+	return !!md[MARKSTREAM_MATH_PLUGIN_APPLIED];
+}
+function markMarkstreamMathPluginApplied(md) {
+	md[MARKSTREAM_MATH_PLUGIN_APPLIED] = true;
+}
 const KATEX_COMMANDS = [
 	"ldots",
 	"cdots",
@@ -12985,6 +13002,233 @@ function findSingleDollarClose(src, startIdx) {
 	}
 	return -1;
 }
+function findUnescapedDelimiter(src, delimiter$1, startIdx = 0) {
+	let searchPos = Math.max(0, startIdx);
+	while (searchPos < src.length) {
+		const index = src.indexOf(delimiter$1, searchPos);
+		if (index === -1) return -1;
+		if (!isEscapedAt(src, index)) return index;
+		searchPos = index + Math.max(1, delimiter$1.length);
+	}
+	return -1;
+}
+function countUnescapedDelimiter(src, delimiter$1, startIdx = 0, endIdx = src.length, excludedRanges = []) {
+	let count = 0;
+	let searchPos = Math.max(0, startIdx);
+	const end = Math.min(src.length, Math.max(0, endIdx));
+	while (searchPos < end) {
+		const index = src.indexOf(delimiter$1, searchPos);
+		if (index === -1 || index >= end) break;
+		const excluded = findRangeAt(excludedRanges, index);
+		if (excluded) {
+			searchPos = Math.max(index + Math.max(1, delimiter$1.length), excluded[1]);
+			continue;
+		}
+		if (!isEscapedAt(src, index)) count++;
+		searchPos = index + Math.max(1, delimiter$1.length);
+	}
+	return count;
+}
+function getTolerantBoundaryLineEndOpenIndex(line, openDelim, closeDelim) {
+	const source = trimRightSpaceOrTab(String(line ?? ""));
+	if (!source.endsWith(openDelim)) return -1;
+	const openIndex = source.length - openDelim.length;
+	if (openIndex <= 0) return -1;
+	if (!trimRightSpaceOrTab(source.slice(0, openIndex)).trim()) return -1;
+	if (isEscapedAt(source, openIndex)) return -1;
+	const codeSpanRanges = buildCodeSpanRanges(source);
+	if (findRangeAt(codeSpanRanges, openIndex)) return -1;
+	const previousOpenCount = countUnescapedDelimiter(source, openDelim, 0, openIndex, codeSpanRanges);
+	if (openDelim === "$$") {
+		if (previousOpenCount % 2 === 1) return -1;
+	} else if (previousOpenCount > countUnescapedDelimiter(source, closeDelim, 0, openIndex, codeSpanRanges)) return -1;
+	return openIndex;
+}
+function isSpaceOrTab(ch) {
+	return ch === " " || ch === "	";
+}
+function trimRightSpaceOrTab(value) {
+	let end = value.length;
+	while (end > 0 && isSpaceOrTab(value[end - 1])) end--;
+	return value.slice(0, end);
+}
+function countLineBreaks(value) {
+	let count = 0;
+	for (let index = 0; index < value.length; index++) if (value[index] === "\n") count++;
+	return count;
+}
+function isAsciiDigit(ch) {
+	if (!ch) return false;
+	const code$1 = ch.charCodeAt(0);
+	return code$1 >= 48 && code$1 <= 57;
+}
+function isThematicLikeLine(trimmed) {
+	if (trimmed.length < 3) return false;
+	const marker = trimmed[0];
+	if (marker !== "-" && marker !== "*" && marker !== "_" && marker !== "=") return false;
+	let markerCount = 0;
+	for (let index = 0; index < trimmed.length; index++) {
+		const ch = trimmed[index];
+		if (ch === marker) {
+			markerCount++;
+			continue;
+		}
+		if (isSpaceOrTab(ch)) continue;
+		return false;
+	}
+	return markerCount >= 3;
+}
+function isMarkdownTableDelimiterCell(cell) {
+	const value = cell.trim();
+	if (!value) return false;
+	let index = 0;
+	if (value[index] === ":") index++;
+	let dashCount = 0;
+	while (value[index] === "-") {
+		dashCount++;
+		index++;
+	}
+	if (dashCount < 3) return false;
+	if (value[index] === ":") index++;
+	return index === value.length;
+}
+function isMarkdownTableDelimiterLine(trimmed) {
+	if (!trimmed.includes("|")) return false;
+	const withoutLeadingPipe = trimmed[0] === "|" ? trimmed.slice(1) : trimmed;
+	return (withoutLeadingPipe.endsWith("|") ? withoutLeadingPipe.slice(0, -1) : withoutLeadingPipe).split("|").every(isMarkdownTableDelimiterCell);
+}
+function isOrderedListBoundaryLine(trimmed) {
+	let index = 0;
+	if (!isAsciiDigit(trimmed[index])) return false;
+	while (isAsciiDigit(trimmed[index])) index++;
+	if (trimmed[index] !== "." && trimmed[index] !== ")") return false;
+	return isSpaceOrTab(trimmed[index + 1]);
+}
+function isTolerantBoundaryStopLine(line) {
+	const trimmed = line.trimStart();
+	if (!trimmed) return true;
+	if (trimmed.startsWith("```") || trimmed.startsWith("~~~") || trimmed.startsWith(":::")) return true;
+	if (trimmed[0] === ">" || trimmed[0] === "<") return true;
+	if (trimmed[0] === "#") {
+		let level = 0;
+		while (trimmed[level] === "#") level++;
+		if (level >= 1 && level <= 6 && isSpaceOrTab(trimmed[level])) return true;
+	}
+	if ((trimmed[0] === "-" || trimmed[0] === "+" || trimmed[0] === "*") && isSpaceOrTab(trimmed[1])) return true;
+	if (isOrderedListBoundaryLine(trimmed)) return true;
+	if (isThematicLikeLine(trimmed)) return true;
+	if (isMarkdownTableDelimiterLine(trimmed)) return true;
+	return false;
+}
+function appendTolerantBoundaryContent(content, line) {
+	if (!content) return line;
+	if (!line) return content;
+	return `${content}\n${line}`;
+}
+function isTolerantMathBlockContent(content) {
+	const stripped = String(content ?? "").trim();
+	if (!stripped) return false;
+	return isMathLike(stripped);
+}
+function hashTolerantBoundaryContent(content) {
+	let hash = 0;
+	for (let index = 0; index < content.length; index++) hash = hash * 31 + content.charCodeAt(index) | 0;
+	return hash.toString(36);
+}
+function getTolerantBoundaryScanWindow(source) {
+	if (source.length <= TOLERANT_BOUNDARY_SCAN_TAIL_CHARS) return {
+		source,
+		lineOffset: 0
+	};
+	let start = source.length - TOLERANT_BOUNDARY_SCAN_TAIL_CHARS;
+	const nextLineBreak = source.indexOf("\n", start);
+	if (nextLineBreak === -1) return {
+		source: "",
+		lineOffset: countLineBreaks(source)
+	};
+	start = nextLineBreak + 1;
+	return {
+		source: source.slice(start),
+		lineOffset: countLineBreaks(source.slice(0, start))
+	};
+}
+function mayContainTolerantMathBlockBoundaryOpener(markdown) {
+	const fullSource = String(markdown ?? "");
+	if (!fullSource || !fullSource.includes("$$") && !fullSource.includes("\\[")) return false;
+	const { source } = getTolerantBoundaryScanWindow(fullSource);
+	if (!source) return false;
+	const lines = source.split(/\r?\n/);
+	const startLine = Math.max(0, lines.length - TOLERANT_BOUNDARY_SCAN_MAX_LINES - 2);
+	const delimiters = [["$$", "$$"], ["\\[", "\\]"]];
+	for (let line = startLine; line < lines.length; line++) {
+		const openingLine = trimRightSpaceOrTab(lines[line]);
+		if (!openingLine) continue;
+		if (isTolerantBoundaryStopLine(openingLine)) continue;
+		for (const [openDelim, closeDelim] of delimiters) if (getTolerantBoundaryLineEndOpenIndex(openingLine, openDelim, closeDelim) !== -1) return true;
+	}
+	return false;
+}
+function getTolerantMathBlockBoundaryStreamKey(markdown) {
+	const fullSource = String(markdown ?? "");
+	if (!fullSource || !fullSource.includes("$$") && !fullSource.includes("\\[")) return null;
+	const { source, lineOffset } = getTolerantBoundaryScanWindow(fullSource);
+	if (!source) return null;
+	const lines = source.split(/\r?\n/);
+	const startLine = Math.max(0, lines.length - TOLERANT_BOUNDARY_SCAN_MAX_LINES - 2);
+	const delimiters = [["$$", "$$"], ["\\[", "\\]"]];
+	for (let line = startLine; line < lines.length - 1; line++) {
+		const openingLine = trimRightSpaceOrTab(lines[line]);
+		for (const [openDelim, closeDelim] of delimiters) {
+			const openIndex = getTolerantBoundaryLineEndOpenIndex(openingLine, openDelim, closeDelim);
+			if (openIndex === -1) continue;
+			let content = "";
+			let stopped = false;
+			for (let currentLine = line + 1; currentLine < lines.length; currentLine++) {
+				if (currentLine - line > TOLERANT_BOUNDARY_SCAN_MAX_LINES) {
+					stopped = true;
+					break;
+				}
+				const current = lines[currentLine];
+				const closeIndex = findUnescapedDelimiter(current, closeDelim);
+				if (closeIndex !== -1) {
+					const nextContent = appendTolerantBoundaryContent(content, current.slice(0, closeIndex));
+					if (!isTolerantMathBlockContent(nextContent)) {
+						stopped = true;
+						break;
+					}
+					const suffix = current.slice(closeIndex + closeDelim.length);
+					const suffixKey = suffix.trim() ? `suffix:${hashTolerantBoundaryContent(suffix)}` : "nosuffix";
+					return [
+						"closed",
+						openDelim,
+						lineOffset + line,
+						openIndex,
+						lineOffset + currentLine,
+						closeIndex,
+						hashTolerantBoundaryContent(nextContent),
+						suffixKey
+					].join(":");
+				}
+				if (isTolerantBoundaryStopLine(current)) {
+					stopped = true;
+					break;
+				}
+				content = appendTolerantBoundaryContent(content, current);
+				if (content.length > TOLERANT_BOUNDARY_SCAN_MAX_CHARS) {
+					stopped = true;
+					break;
+				}
+			}
+			if (!stopped && isTolerantMathBlockContent(content)) return [
+				"pending",
+				openDelim,
+				lineOffset + line,
+				openIndex
+			].join(":");
+		}
+	}
+	return null;
+}
 function isLikelyCurrencyRangeDollar(content, nextChar) {
 	const stripped = String(content ?? "").trim();
 	if (!stripped) return false;
@@ -13005,6 +13249,18 @@ function isLikelyPlaceholderDollar(content) {
 	return /^(?:\.{3,}|…+)$/.test(stripped);
 }
 function applyMath(md, mathOpts) {
+	markMarkstreamMathPluginApplied(md);
+	const pushInlineParagraph = (s, content, line) => {
+		const paragraphContent = String(content ?? "").replace(/^[\t ]+/, "").replace(/[\t ]+$/, "");
+		if (!paragraphContent) return;
+		const paragraphOpen = s.push("paragraph_open", "p", 1);
+		paragraphOpen.map = [line, line + 1];
+		const inlineToken = s.push("inline", "", 0);
+		inlineToken.content = paragraphContent;
+		inlineToken.map = [line, line + 1];
+		inlineToken.children = [];
+		s.push("paragraph_close", "p", -1);
+	};
 	const mathInline = (state, silent) => {
 		const s = state;
 		const strict = !!mathOpts?.strictDelimiters;
@@ -13020,6 +13276,18 @@ function applyMath(md, mathOpts) {
 			return end;
 		};
 		if (/^\*[^*]+/.test(s.src)) return false;
+		if (s.src[s.pos] === "$") {
+			let dollarRunEnd = s.pos + 1;
+			while (s.src[dollarRunEnd] === "$") dollarRunEnd++;
+			const dollarRunLength = dollarRunEnd - s.pos;
+			const nextChar = s.src[dollarRunEnd];
+			if (dollarRunLength >= 3 && (!nextChar || /\s/.test(nextChar))) {
+				const token = s.push("text", "", 0);
+				token.content = s.src.slice(s.pos, dollarRunEnd);
+				s.pos = dollarRunEnd;
+				return true;
+			}
+		}
 		const delimiters = [
 			["$$", "$$"],
 			["$", "$"],
@@ -13383,6 +13651,8 @@ function applyMath(md, mathOpts) {
 		let openDelim = "";
 		let closeDelim = "";
 		let skipFirstLine = false;
+		let prefixBeforeOpen = "";
+		let tolerantBoundary = false;
 		for (const [open, close] of delimiters) if (lineText.startsWith(open)) if (open.includes("[")) if (mathOpts?.strictDelimiters) {
 			if (lineText.replace("\\", "") === "[") {
 				if (startLine + 1 < endLine) {
@@ -13423,8 +13693,11 @@ function applyMath(md, mathOpts) {
 			closeDelim = close;
 			break;
 		}
-		else if (open === "$$" && lineText.endsWith(open) && !lineText.slice(0, lineText.length - open.length).trim().includes(open) && startLine + 1 < endLine) {
-			s.push("text", "", 0).content = lineText.slice(0, lineText.length - open.length);
+		else if ((open === "$$" || open === "\\[") && lineText.endsWith(open) && startLine + 1 < endLine) {
+			const openIndex = getTolerantBoundaryLineEndOpenIndex(lineText, open, close);
+			if (openIndex === -1) continue;
+			prefixBeforeOpen = trimRightSpaceOrTab(lineText.slice(0, openIndex));
+			tolerantBoundary = true;
 			const nextLineStartPos = s.bMarks[startLine + 1] + s.tShift[startLine + 1];
 			lineText = s.src.slice(nextLineStartPos, s.eMarks[startLine + 1]).trim();
 			skipFirstLine = true;
@@ -13434,49 +13707,77 @@ function applyMath(md, mathOpts) {
 			break;
 		}
 		if (!matched) return false;
-		if (silent) return true;
-		if (lineText.includes(closeDelim) && lineText.indexOf(closeDelim) > openDelim.length) {
-			const startDelimIndex = lineText.indexOf(openDelim);
-			const endDelimIndex = lineText.indexOf(closeDelim, startDelimIndex + openDelim.length);
-			const content$1 = lineText.slice(startDelimIndex + openDelim.length, endDelimIndex);
+		if (silent && !tolerantBoundary) return true;
+		const startDelimIndex = lineText.indexOf(openDelim);
+		const closeSearchStart = startDelimIndex + openDelim.length;
+		const escapedPlainBracketCloseIndex = !strict && openDelim === "[" ? lineText.indexOf("\\]", closeSearchStart) : -1;
+		const sameLineCloseDelim = escapedPlainBracketCloseIndex >= 0 ? "\\]" : closeDelim;
+		const sameLineCloseIndex = escapedPlainBracketCloseIndex >= 0 ? escapedPlainBracketCloseIndex : findUnescapedDelimiter(lineText, closeDelim, closeSearchStart);
+		if (!skipFirstLine && sameLineCloseIndex > openDelim.length) {
+			const content$1 = lineText.slice(startDelimIndex + openDelim.length, sameLineCloseIndex);
 			const token$1 = s.push("math_block", "math", 0);
 			token$1.content = normalizeStandaloneBackslashT(content$1);
 			token$1.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
 			token$1.map = [startLine, startLine + 1];
-			token$1.raw = `${openDelim}${content$1}${closeDelim}`;
+			token$1.raw = `${openDelim}${content$1}${sameLineCloseDelim}`;
 			token$1.block = true;
 			token$1.loading = false;
 			s.line = startLine + 1;
+			const trailingAfterClose$1 = lineText.slice(sameLineCloseIndex + sameLineCloseDelim.length);
+			if (trailingAfterClose$1.trim()) pushInlineParagraph(s, trailingAfterClose$1, startLine);
 			return true;
 		}
 		let nextLine = startLine;
 		let content = "";
 		let found = false;
-		const firstLineContent = lineText === openDelim ? "" : lineText.slice(openDelim.length);
+		let trailingAfterClose = "";
+		let trailingAfterCloseLine = startLine;
+		const firstLineContent = skipFirstLine ? lineText : lineText === openDelim ? "" : lineText.slice(openDelim.length);
 		const fallbackPlainBracketClose = !strict && openDelim === "\\[" ? "]" : "";
-		if (firstLineContent.includes(closeDelim)) {
-			const endIndex = firstLineContent.indexOf(closeDelim);
+		const firstLineCloseIndex = findUnescapedDelimiter(firstLineContent, closeDelim);
+		if (firstLineCloseIndex !== -1) {
+			const endIndex = firstLineCloseIndex;
 			content = firstLineContent.slice(0, endIndex);
+			trailingAfterClose = firstLineContent.slice(endIndex + closeDelim.length);
+			trailingAfterCloseLine = skipFirstLine ? startLine + 1 : startLine;
 			found = true;
-			nextLine = startLine;
+			nextLine = trailingAfterCloseLine;
 		} else {
 			if (firstLineContent && !skipFirstLine) content = firstLineContent;
 			for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
 				const lineStart = s.bMarks[nextLine] + s.tShift[nextLine];
 				const lineEnd = s.eMarks[nextLine];
 				const currentLine = s.src.slice(lineStart, lineEnd);
+				const currentLineTrimmed = currentLine.trim();
+				if (!strict && openDelim === "[" && currentLineTrimmed === "\\]") {
+					closeDelim = "\\]";
+					found = true;
+					break;
+				}
 				if (fallbackPlainBracketClose && currentLine.trim() === fallbackPlainBracketClose) {
 					closeDelim = fallbackPlainBracketClose;
 					found = true;
 					break;
 				}
-				if (currentLine.trim() === closeDelim) {
+				if (currentLineTrimmed === closeDelim) {
+					found = true;
+					break;
+				} else if (!strict && openDelim === "[" && currentLine.includes("\\]")) {
 					found = true;
+					const endIndex = currentLine.indexOf("\\]");
+					closeDelim = "\\]";
+					const beforeClose = currentLine.slice(0, endIndex);
+					if (beforeClose) content += (content ? "\n" : "") + beforeClose;
+					trailingAfterClose = currentLine.slice(endIndex + closeDelim.length);
+					trailingAfterCloseLine = nextLine;
 					break;
-				} else if (currentLine.includes(closeDelim)) {
+				} else if (findUnescapedDelimiter(currentLine, closeDelim) !== -1) {
 					found = true;
-					const endIndex = currentLine.indexOf(closeDelim);
-					content += (content ? "\n" : "") + currentLine.slice(0, endIndex);
+					const endIndex = findUnescapedDelimiter(currentLine, closeDelim);
+					const beforeClose = currentLine.slice(0, endIndex);
+					if (beforeClose) content += (content ? "\n" : "") + beforeClose;
+					trailingAfterClose = currentLine.slice(endIndex + closeDelim.length);
+					trailingAfterCloseLine = nextLine;
 					break;
 				}
 				content += (content ? "\n" : "") + currentLine;
@@ -13484,7 +13785,9 @@ function applyMath(md, mathOpts) {
 		}
 		if ((!allowLoading || strict) && !found) return false;
 		const hasMarkdownPrefix = /^\s*!\[/.test(content);
-		if (!(openDelim === "$$" ? !hasMarkdownPrefix : openDelim === "[" ? isPlainBracketMathLike(content) : isMathLike(content))) return false;
+		if (!(tolerantBoundary ? !hasMarkdownPrefix && isTolerantMathBlockContent(content) : openDelim === "$$" ? !hasMarkdownPrefix : openDelim === "[" ? isPlainBracketMathLike(content) : isMathLike(content))) return false;
+		if (silent) return true;
+		if (prefixBeforeOpen) pushInlineParagraph(s, prefixBeforeOpen, startLine);
 		const token = s.push("math_block", "math", 0);
 		token.content = normalizeStandaloneBackslashT(content);
 		token.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
@@ -13493,6 +13796,7 @@ function applyMath(md, mathOpts) {
 		token.block = true;
 		token.loading = !found;
 		s.line = nextLine + 1;
+		if (trailingAfterClose.trim()) pushInlineParagraph(s, trailingAfterClose, trailingAfterCloseLine);
 		return true;
 	};
 	const explicitMathBlockBeforeSetext = (state, startLine, endLine, silent) => {
@@ -16833,6 +17137,8 @@ function parseParagraph(tokens, index, options) {
 //#endregion
 //#region src/parser/index.ts
 const streamParseEnvCache = /* @__PURE__ */ new WeakMap();
+const tolerantMathBoundaryStreamCache = /* @__PURE__ */ new WeakMap();
+const TOLERANT_BOUNDARY_SPLIT_OPENERS = ["$$", "\\["];
 function getNodeFields(node) {
 	return node;
 }
@@ -17012,13 +17318,89 @@ function shouldResetTopLevelStreamCacheForFinalAutoParse(md, options) {
 	const stream = md.stream;
 	return options.final === true && streamParse === "auto" && internalOptions.__disableStreamParse !== true && stream?.enabled === true && typeof stream.reset === "function";
 }
+function clearTolerantMathBoundaryStreamCache(md) {
+	tolerantMathBoundaryStreamCache.delete(md);
+}
+function setTolerantMathBoundaryStreamCache(md, source, key) {
+	tolerantMathBoundaryStreamCache.set(md, {
+		source,
+		key,
+		pendingCandidate: key === null && mayContainTolerantMathBlockBoundaryOpener(source)
+	});
+}
+function sourceEndsWithSplitTolerantBoundaryPrefix(source) {
+	return source.endsWith("$") || source.endsWith("\\");
+}
+function sourceEndsWithCompleteTolerantBoundaryOpener(source) {
+	const lastLineStart = Math.max(source.lastIndexOf("\n") + 1, 0);
+	const lastLine = source.slice(lastLineStart).replace(/[\t ]+$/, "");
+	return TOLERANT_BOUNDARY_SPLIT_OPENERS.some((open) => lastLine.endsWith(open));
+}
+function appendedChunkMayAffectTolerantMathBoundary(previousSource, appended) {
+	if (!appended) return false;
+	if (appended.includes("$$") || appended.includes("\\[") || appended.includes("\\]")) return true;
+	if (previousSource.endsWith("$") && appended[0] === "$") return true;
+	if (previousSource.endsWith("\\") && (appended[0] === "[" || appended[0] === "]")) return true;
+	if (sourceEndsWithCompleteTolerantBoundaryOpener(previousSource) && /[\r\n]/.test(appended)) return true;
+	return false;
+}
+function syncTolerantMathBoundaryStreamCache(md, source) {
+	if (!hasMarkstreamMathPlugin(md)) return;
+	const stream = md.stream;
+	if (typeof stream?.reset !== "function") return;
+	const owner = md;
+	const previous = tolerantMathBoundaryStreamCache.get(owner);
+	if (previous?.source === source) return;
+	if (previous && source.startsWith(previous.source)) {
+		const appended = source.slice(previous.source.length);
+		if (previous.key === null && previous.pendingCandidate === false && !appendedChunkMayAffectTolerantMathBoundary(previous.source, appended) && !sourceEndsWithSplitTolerantBoundaryPrefix(source)) {
+			previous.source = source;
+			return;
+		}
+	}
+	const nextKey = getTolerantMathBlockBoundaryStreamKey(source);
+	const sourceWasReplaced = previous ? !source.startsWith(previous.source) : false;
+	if (previous && (sourceWasReplaced || previous.key !== nextKey)) stream.reset();
+	else if (!previous && nextKey) stream.reset();
+	setTolerantMathBoundaryStreamCache(md, source, nextKey);
+}
 function shouldCloneTopLevelStreamTokens(options) {
 	return typeof options.preTransformTokens === "function" || typeof options.postTransformTokens === "function";
 }
+function sameTokenMap(left, right) {
+	const leftMap = left?.map;
+	const rightMap = right?.map;
+	if (leftMap === rightMap) return true;
+	if (!Array.isArray(leftMap) || !Array.isArray(rightMap)) return false;
+	return leftMap.length === rightMap.length && leftMap.every((value, index) => value === rightMap[index]);
+}
+function isSameTokenShape(left, right) {
+	return !!left && !!right && left.type === right.type && left.tag === right.tag && left.nesting === right.nesting && left.markup === right.markup && left.content === right.content && sameTokenMap(left, right);
+}
+function isParagraphTokenTriplet(tokens, index) {
+	return tokens[index]?.type === "paragraph_open" && tokens[index + 1]?.type === "inline" && tokens[index + 2]?.type === "paragraph_close";
+}
+function hasAdjacentDuplicateParagraphTokenTriplet(tokens) {
+	for (let index = 0; index + 5 < tokens.length; index++) if (isParagraphTokenTriplet(tokens, index) && isParagraphTokenTriplet(tokens, index + 3) && isSameTokenShape(tokens[index], tokens[index + 3]) && isSameTokenShape(tokens[index + 1], tokens[index + 4]) && isSameTokenShape(tokens[index + 2], tokens[index + 5])) return true;
+	return false;
+}
+function shouldFallbackDuplicateTolerantMathStreamTokens(md, source, tokens) {
+	return hasMarkstreamMathPlugin(md) && mayContainTolerantMathBlockBoundaryOpener(source) && hasAdjacentDuplicateParagraphTokenTriplet(tokens);
+}
+function shouldUseSyncParseForPendingTolerantMathBoundary(md) {
+	const cache = tolerantMathBoundaryStreamCache.get(md);
+	return typeof cache?.key === "string" && cache.key.startsWith("pending:");
+}
 function parseTopLevelTokens(md, source, env, options) {
 	if (options.customHtmlTags?.length) env.__markstreamCustomHtmlTags = options.customHtmlTags;
 	if (!shouldUseTopLevelStreamParse(md, options)) return md.parse(source, env);
+	syncTolerantMathBoundaryStreamCache(md, source);
+	if (shouldUseSyncParseForPendingTolerantMathBoundary(md)) return md.parse(source, env);
 	const tokens = md.stream.parse(source, getStableStreamEnv(md, env));
+	if (shouldFallbackDuplicateTolerantMathStreamTokens(md, source, tokens)) {
+		md.stream?.reset?.();
+		return md.parse(source, env);
+	}
 	if (!shouldCloneTopLevelStreamTokens(options)) return tokens;
 	const timing = getParseTiming(options);
 	if (!timing) return cloneMarkdownTokens(tokens, true);
@@ -18224,7 +18606,10 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 	const parseStartedAt = timing ? getParserNow() : 0;
 	const isFinal = !!options.final;
 	let safeMarkdown = (markdown ?? "").toString().replace(/([^\\])\r(ight|ho)/g, "$1\\r$2").replace(/([^\\])\n(abla|eq|ot|exists)/g, "$1\\n$2");
-	if (shouldResetTopLevelStreamCacheForFinalAutoParse(md, options)) md.stream.reset();
+	if (shouldResetTopLevelStreamCacheForFinalAutoParse(md, options)) {
+		md.stream.reset();
+		clearTolerantMathBoundaryStreamCache(md);
+	}
 	if (!isFinal) {
 		if (safeMarkdown.endsWith("- *")) safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*");
 		if (/(?:^|\n)\s*-\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*-\s*$/, (m) => {