stream-markdown-parser 1.0.7 → 1.0.9

package/dist/index.cjs

@@ -10899,6 +10899,18 @@ function parseLooseInlineAttrs(input) {
 	}
 	return out;
 }
+function offsetTokenMaps(tokens, lineOffset, maxEndLine) {
+	for (const token of tokens) {
+		const mappedToken = token;
+		const map$1 = mappedToken.map;
+		if (Array.isArray(map$1) && map$1.length >= 2) {
+			const startLine = Number(map$1[0]);
+			const endLine = Number(map$1[1]);
+			if (Number.isFinite(startLine) && Number.isFinite(endLine)) mappedToken.map = [startLine + lineOffset, Math.min(endLine + lineOffset, maxEndLine)];
+		}
+		if (Array.isArray(mappedToken.children)) offsetTokenMaps(mappedToken.children, lineOffset, maxEndLine);
+	}
+}
 function applyContainers(md) {
 	[
 		"admonition",
@@ -10963,6 +10975,7 @@ function applyContainers(md) {
 		if (!found) nextLine = endLine;
 		const tokenOpen = s.push("vmr_container_open", "div", 1);
 		tokenOpen.attrSet("class", `vmr-container vmr-container-${name}`);
+		tokenOpen.map = [startLine, found ? nextLine : endLine];
 		tokenOpen.meta = {
 			...tokenOpen.meta ?? {},
 			unclosed: !found && !envFinal
@@ -10996,6 +11009,7 @@ function applyContainers(md) {
 			if (prevToken) prevToken.raw = innerSrc;
 			const innerTokens = [];
 			s.md.block.parse(innerSrc, s.md, s.env, innerTokens);
+			offsetTokenMaps(innerTokens, startLine + 1, startLine + 1 + contentLines.length);
 			s.tokens.push(...innerTokens);
 		}
 		if (found) s.push("vmr_container_close", "div", -1);
@@ -13508,6 +13522,7 @@ const SPAN_CURLY_RE = /span\{([^}]+)\}/;
 const OPERATORNAME_SPAN_RE = /\\operatorname\{span\}\{((?:[^{}]|\{[^}]*\})+)\}/;
 const SINGLE_BACKSLASH_NEWLINE_RE = /(^|[^\\])\\\r?\n/g;
 const ENDING_SINGLE_BACKSLASH_RE = /(^|[^\\])\\$/g;
+const FACTORIAL_PRECEDING_RE = /[\p{L}\p{M}\p{N}\p{Pe}\p{Pf}'′″‴|‖]/u;
 const DEFAULT_MATH_RE = new RegExp(`(${CONTROL_CHARS_CLASS})|(${ESCAPED_KATEX_COMMANDS})\\b`, "g");
 const MATH_RE_CACHE = /* @__PURE__ */ new Map();
 const BRACE_CMD_RE_CACHE = /* @__PURE__ */ new Map();
@@ -13547,6 +13562,13 @@ function countUnescapedStrong(s) {
 	while (re.exec(s) !== null) c++;
 	return c;
 }
+function escapeStandaloneExclamation(value) {
+	return value.replace(/(^|[^\\])!+/gu, (match, prefix) => {
+		if (prefix && FACTORIAL_PRECEDING_RE.test(prefix)) return match;
+		const marks = prefix ? match.slice(prefix.length) : match;
+		return `${prefix}${"\\!".repeat(marks.length)}`;
+	});
+}
 function findLastUnescapedStrongMarker(s) {
 	const re = /(^|[^\\])(__|\*\*)/g;
 	let m;
@@ -13571,7 +13593,7 @@ function normalizeStandaloneBackslashT(s, opts) {
 		}
 		return m;
 	});
-	if (escapeExclamation) out = out.replace(/(^|[^\\])!/g, "$1\\!");
+	if (escapeExclamation) out = escapeStandaloneExclamation(out);
 	let result = out;
 	const braceCmdRe = getBraceCmdRegex(useDefault, useDefault ? void 0 : commands);
 	result = result.replace(braceCmdRe, (_m, p1, p2) => `${p1}\\${p2}{`);
@@ -16863,6 +16885,74 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 	return result;
 }
 
+//#endregion
+//#region src/parser/node-source-map.ts
+function mapSourceLineRange(startLine, endLine, options) {
+	const mapper = options?.__sourceLineMapper;
+	if (!mapper) return {
+		startLine,
+		endLine
+	};
+	const mappedStartRange = mapper(startLine);
+	const mappedEndLine = endLine > startLine ? mapper(endLine - 1).endLine : mapper(endLine).startLine;
+	return {
+		startLine: mappedStartRange.startLine,
+		endLine: Math.max(mappedStartRange.startLine, mappedEndLine)
+	};
+}
+function lineAtOffset(source, offset) {
+	const target = Math.max(0, Math.min(source.length, Math.trunc(offset)));
+	let line = 0;
+	for (let i = 0; i < target; i++) if (source[i] === "\n") line++;
+	return line;
+}
+function sourceLineRangeFromOffsets(source, start, end) {
+	const startIndex = Math.max(0, Math.min(source.length, Math.trunc(start)));
+	const endIndex = Math.max(startIndex, Math.min(source.length, Math.trunc(end)));
+	const startLine = lineAtOffset(source, startIndex);
+	let endLine = lineAtOffset(source, endIndex);
+	if (endIndex > startIndex && source[endIndex - 1] !== "\n") endLine++;
+	return {
+		startLine,
+		endLine
+	};
+}
+function createSourceMapFromOffsets(source, start, end, options) {
+	const range = sourceLineRangeFromOffsets(source, start, end);
+	return mapSourceLineRange(range.startLine, range.endLine, options);
+}
+function readSourceMap(token, options) {
+	const map$1 = token?.map;
+	if (!Array.isArray(map$1) || map$1.length < 2) return null;
+	const startLine = Number(map$1[0]);
+	const endLine = Number(map$1[1]);
+	if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) return null;
+	return mapSourceLineRange(startLine, endLine, options);
+}
+function applyNodeSourceMap(node, token, options) {
+	if (!options?.includeSourceMap) return node;
+	const sourceMap = readSourceMap(token, options);
+	if (!sourceMap) return node;
+	node.sourceMap = sourceMap;
+	if (node.type === "code_block") {
+		const codeNode = node;
+		codeNode.startLine = sourceMap.startLine;
+		codeNode.endLine = sourceMap.endLine;
+	}
+	return node;
+}
+function applyNodeSourceMapRange(node, token, endLine, options) {
+	if (!options?.includeSourceMap) return node;
+	const map$1 = token?.map;
+	if (!Array.isArray(map$1) || map$1.length < 2) return node;
+	const startLine = Number(map$1[0]);
+	const tokenEndLine = Number(map$1[1]);
+	const rangeEndLine = Number(endLine);
+	if (!Number.isFinite(startLine) || !Number.isFinite(tokenEndLine) || !Number.isFinite(rangeEndLine)) return node;
+	node.sourceMap = mapSourceLineRange(startLine, Math.max(tokenEndLine, rangeEndLine), options);
+	return node;
+}
+
 //#endregion
 //#region src/parser/node-parsers/list-parser.ts
 function trimInlineTokenTail(token) {
@@ -16947,11 +17037,13 @@ function parseList(tokens, index, options) {
 				trimInlineTokenTail(contentToken);
 			}
 			const paragraphRaw = String(contentToken.content ?? "");
-			itemChildren.push({
+			const paragraphNode = {
 				type: "paragraph",
 				children: parseInlineTokens(contentToken.children || [], paragraphRaw, preToken, linkifyContext.options()),
 				raw: paragraphRaw
-			});
+			};
+			if (options?.includeSourceMap) applyNodeSourceMap(paragraphNode, tokens[k], options);
+			itemChildren.push(paragraphNode);
 			linkifyContext.remember(paragraphRaw);
 			k += 3;
 		} else if (tokens[k].type === "blockquote_open") {
@@ -16972,14 +17064,16 @@ function parseList(tokens, index, options) {
 				k = handled[1];
 			} else k += 1;
 		}
-		listItems.push({
+		const listItemNode = {
 			type: "list_item",
 			children: itemChildren,
 			raw: itemChildren.map((child) => child.raw).join("")
-		});
+		};
+		if (options?.includeSourceMap) applyNodeSourceMap(listItemNode, tokens[j], options);
+		listItems.push(listItemNode);
 		j = k + 1;
 	} else j += 1;
-	return [{
+	const listNode = {
 		type: "list",
 		ordered: token.type === "ordered_list_open",
 		start: (() => {
@@ -16993,7 +17087,9 @@ function parseList(tokens, index, options) {
 		})(),
 		items: listItems,
 		raw: listItems.map((item) => item.raw).join("\n")
-	}, j + 1];
+	};
+	if (options?.includeSourceMap) applyNodeSourceMap(listNode, token, options);
+	return [listNode, j + 1];
 }
 
 //#endregion
@@ -17012,17 +17108,20 @@ function parseAdmonition(tokens, index, match, options) {
 				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, linkifyContext.options()),
 				raw: String(contentToken.content ?? "")
 			};
+			if (options?.includeSourceMap) applyNodeSourceMap(paragraphNode, tokens[j], options);
 			admonitionChildren.push(paragraphNode);
 			linkifyContext.remember(paragraphNode.raw);
 		}
 		j += 3;
 	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
 		const [listNode, newIndex] = parseList(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(listNode, tokens[j], options);
 		admonitionChildren.push(listNode);
 		linkifyContext.remember(listNode.raw);
 		j = newIndex;
 	} else if (tokens[j].type === "blockquote_open") {
 		const [blockquoteNode, newIndex] = parseBlockquote(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(blockquoteNode, tokens[j], options);
 		admonitionChildren.push(blockquoteNode);
 		linkifyContext.remember(blockquoteNode.raw);
 		j = newIndex;
@@ -17110,17 +17209,20 @@ function parseContainer(tokens, index, options) {
 				children: parseInlineTokens((i !== -1 ? childrenArr.slice(0, i) : childrenArr) || [], void 0, void 0, linkifyContext.options()),
 				raw: String(contentToken.content ?? "").replace(/\n:+$/, "").replace(/\n\s*:::\s*$/, "")
 			};
+			if (options?.includeSourceMap) applyNodeSourceMap(paragraphNode, tokens[j], options);
 			children.push(paragraphNode);
 			linkifyContext.remember(paragraphNode.raw);
 		}
 		j += 3;
 	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
 		const [listNode, newIndex] = parseList(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(listNode, tokens[j], options);
 		children.push(listNode);
 		linkifyContext.remember(listNode.raw);
 		j = newIndex;
 	} else if (tokens[j].type === "blockquote_open") {
 		const [blockquoteNode, newIndex] = parseBlockquote(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(blockquoteNode, tokens[j], options);
 		children.push(blockquoteNode);
 		linkifyContext.remember(blockquoteNode.raw);
 		j = newIndex;
@@ -17162,49 +17264,55 @@ function parseBlockquote(tokens, index, options) {
 	const blockquoteChildren = [];
 	const linkifyContext = createLinkifyDemotionContextTracker(options, true);
 	let j = index + 1;
-	while (j < tokens.length && tokens[j].type !== "blockquote_close") switch (tokens[j].type) {
-		case "paragraph_open": {
-			const contentToken = tokens[j + 1];
-			const paragraphNode = {
-				type: "paragraph",
-				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, linkifyContext.options()),
-				raw: String(contentToken.content ?? "")
-			};
-			blockquoteChildren.push(paragraphNode);
-			linkifyContext.remember(paragraphNode.raw);
-			j += 3;
-			break;
-		}
-		case "bullet_list_open":
-		case "ordered_list_open": {
-			const [listNode, newIndex] = parseList(tokens, j, linkifyContext.options());
-			blockquoteChildren.push(listNode);
-			linkifyContext.remember(listNode.raw);
-			j = newIndex;
-			break;
-		}
-		case "blockquote_open": {
-			const [nestedBlockquote, newIndex] = parseBlockquote(tokens, j, linkifyContext.options());
-			blockquoteChildren.push(nestedBlockquote);
-			linkifyContext.remember(nestedBlockquote.raw);
-			j = newIndex;
-			break;
-		}
-		default: {
-			const handled = parseCommonBlockToken(tokens, j, linkifyContext.options(), containerTokenHandlers);
-			if (handled) {
-				blockquoteChildren.push(handled[0]);
-				linkifyContext.remember(handled[0].raw);
-				j = handled[1];
-			} else j++;
-			break;
+	while (j < tokens.length && tokens[j].type !== "blockquote_close") {
+		const token = tokens[j];
+		switch (token.type) {
+			case "paragraph_open": {
+				const contentToken = tokens[j + 1];
+				const paragraphNode = {
+					type: "paragraph",
+					children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, linkifyContext.options()),
+					raw: String(contentToken.content ?? "")
+				};
+				if (options?.includeSourceMap) applyNodeSourceMap(paragraphNode, token, options);
+				blockquoteChildren.push(paragraphNode);
+				linkifyContext.remember(paragraphNode.raw);
+				j += 3;
+				break;
+			}
+			case "bullet_list_open":
+			case "ordered_list_open": {
+				const [listNode, newIndex] = parseList(tokens, j, linkifyContext.options());
+				blockquoteChildren.push(listNode);
+				linkifyContext.remember(listNode.raw);
+				j = newIndex;
+				break;
+			}
+			case "blockquote_open": {
+				const [nestedBlockquote, newIndex] = parseBlockquote(tokens, j, linkifyContext.options());
+				blockquoteChildren.push(nestedBlockquote);
+				linkifyContext.remember(nestedBlockquote.raw);
+				j = newIndex;
+				break;
+			}
+			default: {
+				const handled = parseCommonBlockToken(tokens, j, linkifyContext.options(), containerTokenHandlers);
+				if (handled) {
+					blockquoteChildren.push(handled[0]);
+					linkifyContext.remember(handled[0].raw);
+					j = handled[1];
+				} else j++;
+				break;
+			}
 		}
 	}
-	return [{
+	const blockquoteNode = {
 		type: "blockquote",
 		children: blockquoteChildren,
 		raw: blockquoteChildren.map((child) => child.raw).join("\n")
-	}, j + 1];
+	};
+	if (options?.includeSourceMap) applyNodeSourceMap(blockquoteNode, tokens[index], options);
+	return [blockquoteNode, j + 1];
 }
 
 //#endregion
@@ -17562,17 +17670,20 @@ function parseVmrContainer(tokens, index, options) {
 				children: parseInlineTokens(contentToken.children || [], void 0, void 0, linkifyContext.options()),
 				raw: String(contentToken.content ?? "")
 			};
+			if (options?.includeSourceMap) applyNodeSourceMap(paragraphNode, tokens[j], options);
 			children.push(paragraphNode);
 			linkifyContext.remember(paragraphNode.raw);
 		}
 		j += 3;
 	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
 		const [listNode, newIndex] = parseList(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(listNode, tokens[j], options);
 		children.push(listNode);
 		linkifyContext.remember(listNode.raw);
 		j = newIndex;
 	} else if (tokens[j].type === "blockquote_open") {
 		const [blockquoteNode, newIndex] = parseBlockquote(tokens, j, linkifyContext.options());
+		if (options?.includeSourceMap) applyNodeSourceMap(blockquoteNode, tokens[j], options);
 		children.push(blockquoteNode);
 		linkifyContext.remember(blockquoteNode.raw);
 		j = newIndex;
@@ -17603,6 +17714,14 @@ function parseVmrContainer(tokens, index, options) {
 		raw
 	}, hasCloseToken ? j + 1 : j];
 }
+function applyPairedBlockSourceMap(node, openToken, closeToken, options) {
+	if (closeToken?.type.endsWith("_close")) {
+		let endLine = Array.isArray(closeToken.map) ? Number(closeToken.map[1]) : NaN;
+		if (!Number.isFinite(endLine)) endLine = Array.isArray(openToken.map) ? Number(openToken.map[1]) + 1 : NaN;
+		return applyNodeSourceMapRange(node, openToken, endLine, options);
+	}
+	return applyNodeSourceMap(node, openToken, options);
+}
 function stripWrapperNewlines(s) {
 	return s.replace(/^\r?\n/, "").replace(/\r?\n$/, "");
 }
@@ -17661,6 +17780,7 @@ function findNextCustomHtmlBlockFromSource(source, tag, startIndex) {
 		const end = openEnd + 1;
 		return {
 			raw: source.slice(openStart, end),
+			start: openStart,
 			end
 		};
 	}
@@ -17678,6 +17798,7 @@ function findNextCustomHtmlBlockFromSource(source, tag, startIndex) {
 		const lt = source.indexOf("<", i);
 		if (lt === -1) return {
 			raw: source.slice(openStart),
+			start: openStart,
 			end: source.length
 		};
 		if (isCloseAt(lt)) {
@@ -17688,6 +17809,7 @@ function findNextCustomHtmlBlockFromSource(source, tag, startIndex) {
 				const end = gt + 1;
 				return {
 					raw: source.slice(openStart, end),
+					start: openStart,
 					end
 				};
 			}
@@ -17705,6 +17827,7 @@ function findNextCustomHtmlBlockFromSource(source, tag, startIndex) {
 	}
 	return {
 		raw: source.slice(openStart),
+		start: openStart,
 		end: source.length
 	};
 }
@@ -17723,17 +17846,34 @@ function lineToIndex(source, line) {
 }
 function parseBasicBlockToken(tokens, index, options) {
 	const token = tokens[index];
+	const includeSourceMap = options?.includeSourceMap === true;
 	switch (token.type) {
-		case "heading_open": return [parseHeading(tokens, index, options), index + 3];
-		case "code_block": return [parseCodeBlock(token), index + 1];
-		case "fence": return [parseFenceToken(token), index + 1];
-		case "math_block": return [parseMathBlock(token), index + 1];
+		case "heading_open": {
+			const node = parseHeading(tokens, index, options);
+			if (includeSourceMap) applyNodeSourceMap(node, token, options);
+			return [node, index + 3];
+		}
+		case "code_block": {
+			const node = parseCodeBlock(token);
+			if (includeSourceMap) applyNodeSourceMap(node, token, options);
+			return [node, index + 1];
+		}
+		case "fence": {
+			const node = parseFenceToken(token);
+			if (includeSourceMap) applyNodeSourceMap(node, token, options);
+			return [node, index + 1];
+		}
+		case "math_block": {
+			const node = parseMathBlock(token);
+			if (includeSourceMap) applyNodeSourceMap(node, token, options);
+			return [node, index + 1];
+		}
 		case "html_block": {
 			const htmlBlockNode = parseHtmlBlock(token);
 			const tagSets = htmlBlockNode.tag ? getHtmlTagSets(options?.customHtmlTags) : null;
 			if (htmlBlockNode.tag && htmlBlockNode.loading && tagSets && !tagSets.allowedTagSet.has(htmlBlockNode.tag)) {
 				const content = String(token.content ?? "").replace(/\n+$/, "");
-				return [{
+				const paragraphNode = {
 					type: "paragraph",
 					children: content ? [{
 						type: "text",
@@ -17741,7 +17881,9 @@ function parseBasicBlockToken(tokens, index, options) {
 						raw: content
 					}] : [],
 					raw: content
-				}, index + 1];
+				};
+				if (includeSourceMap) applyNodeSourceMap(paragraphNode, token, options);
+				return [paragraphNode, index + 1];
 			}
 			if (htmlBlockNode.tag && tagSets?.customTagSet?.has(htmlBlockNode.tag)) {
 				const tag = htmlBlockNode.tag;
@@ -17770,30 +17912,41 @@ function parseBasicBlockToken(tokens, index, options) {
 					attrs.push([name, value]);
 				}
 				const loading = !options?.final && !selfClosing && closeRange == null;
-				return [{
+				const customNode = {
 					type: tag,
 					tag,
 					content: stripWrapperNewlines(inner),
 					raw: String(fromSource?.raw ?? htmlBlockNode.raw ?? rawHtml),
 					loading,
 					attrs: attrs.length ? attrs : void 0
-				}, index + 1];
+				};
+				if (includeSourceMap) if (fromSource) customNode.sourceMap = createSourceMapFromOffsets(source, fromSource.start, fromSource.end, options);
+				else applyNodeSourceMap(customNode, token, options);
+				return [customNode, index + 1];
 			}
+			if (includeSourceMap) applyNodeSourceMap(htmlBlockNode, token, options);
 			return [htmlBlockNode, index + 1];
 		}
 		case "table_open": {
 			const [tableNode, newIndex] = parseTable(tokens, index, options);
+			if (includeSourceMap) applyNodeSourceMap(tableNode, token, options);
 			return [tableNode, newIndex];
 		}
 		case "dl_open": {
 			const [definitionListNode, newIndex] = parseDefinitionList(tokens, index, options);
+			if (includeSourceMap) applyNodeSourceMap(definitionListNode, token, options);
 			return [definitionListNode, newIndex];
 		}
 		case "footnote_open": {
 			const [footnoteNode, newIndex] = parseFootnote(tokens, index, options);
+			if (includeSourceMap) applyNodeSourceMap(footnoteNode, token, options);
 			return [footnoteNode, newIndex];
 		}
-		case "hr": return [parseThematicBreak(), index + 1];
+		case "hr": {
+			const node = parseThematicBreak();
+			if (includeSourceMap) applyNodeSourceMap(node, token, options);
+			return [node, index + 1];
+		}
 		default: break;
 	}
 	return null;
@@ -17801,7 +17954,9 @@ function parseBasicBlockToken(tokens, index, options) {
 function parseCommonBlockToken(tokens, index, options, handlers) {
 	const basicResult = parseBasicBlockToken(tokens, index, options);
 	if (basicResult) return basicResult;
-	switch (tokens[index].type) {
+	const token = tokens[index];
+	const includeSourceMap = options?.includeSourceMap === true;
+	switch (token.type) {
 		case "container_warning_open":
 		case "container_info_open":
 		case "container_note_open":
@@ -17809,15 +17964,26 @@ function parseCommonBlockToken(tokens, index, options, handlers) {
 		case "container_danger_open":
 		case "container_caution_open":
 		case "container_error_open":
-			if (handlers?.parseContainer) return handlers.parseContainer(tokens, index, options);
+			if (handlers?.parseContainer) {
+				const result = handlers.parseContainer(tokens, index, options);
+				if (includeSourceMap) applyPairedBlockSourceMap(result[0], token, tokens[result[1] - 1], options);
+				return result;
+			}
 			break;
 		case "container_open":
 			if (handlers?.matchAdmonition) {
 				const result = handlers.matchAdmonition(tokens, index, options);
-				if (result) return result;
+				if (result) {
+					if (includeSourceMap) applyPairedBlockSourceMap(result[0], token, tokens[result[1] - 1], options);
+					return result;
+				}
 			}
 			break;
-		case "vmr_container_open": return parseVmrContainer(tokens, index, options);
+		case "vmr_container_open": {
+			const result = parseVmrContainer(tokens, index, options);
+			if (includeSourceMap) applyPairedBlockSourceMap(result[0], token, tokens[result[1] - 1], options);
+			return result;
+		}
 		default: break;
 	}
 	return null;
@@ -17866,6 +18032,15 @@ function finishTimedParse(result, timing, startedAt) {
 	if (timing) addTiming(timing, "parseMarkdownToStructureTotalMs", getParserNow() - startedAt);
 	return result;
 }
+function applyPostTransformNodes(nodes, options) {
+	const transform = options.postTransformNodes;
+	if (typeof transform !== "function") return nodes;
+	const transformed = transform(nodes);
+	return Array.isArray(transformed) ? transformed : nodes;
+}
+function finishParsedNodes(result, options, timing, startedAt) {
+	return finishTimedParse(applyPostTransformNodes(result, options), timing, startedAt);
+}
 function processTokensWithTiming(tokens, options, timing) {
 	if (!timing) return processTokens(tokens, options);
 	const startedAt = getParserNow();
@@ -18031,8 +18206,24 @@ function shouldResetTopLevelStreamCacheForFinalAutoParse(md, options) {
 function clearTolerantMathBoundaryStreamCache(md) {
 	tolerantMathBoundaryStreamCache.delete(md);
 }
-function setTolerantMathBoundaryStreamCache(md, source, key) {
+function createExplicitBracketMathContext() {
+	return {
+		fenceChar: "",
+		fenceInBlockquote: false,
+		fenceInList: false,
+		fenceLen: 0,
+		fenceListIndent: 0,
+		inFence: false,
+		inMath: false,
+		listContentIndent: null
+	};
+}
+function cloneExplicitBracketMathContext(context) {
+	return { ...context };
+}
+function setTolerantMathBoundaryStreamCache(md, source, key, explicitBracketMath = scanExplicitBracketMathStreamState(source).state) {
 	tolerantMathBoundaryStreamCache.set(md, {
+		explicitBracketMath,
 		source,
 		key,
 		pendingCandidate: key === null && mayContainTolerantMathBlockBoundaryOpener(source)
@@ -18048,12 +18239,235 @@ function sourceEndsWithCompleteTolerantBoundaryOpener(source) {
 }
 function appendedChunkMayAffectTolerantMathBoundary(previousSource, appended) {
 	if (!appended) return false;
-	if (appended.includes("$$") || appended.includes("\\[") || appended.includes("\\]")) return true;
+	if (appended.includes("$$") || appended.includes("\\[")) return true;
 	if (previousSource.endsWith("$") && appended[0] === "$") return true;
-	if (previousSource.endsWith("\\") && (appended[0] === "[" || appended[0] === "]")) return true;
+	if (previousSource.endsWith("\\") && appended[0] === "[") return true;
 	if (sourceEndsWithCompleteTolerantBoundaryOpener(previousSource) && /[\r\n]/.test(appended)) return true;
 	return false;
 }
+function isEscapedDelimiterAt(source, index) {
+	let cursor = index - 1;
+	let backslashes = 0;
+	while (cursor >= 0 && source[cursor] === "\\") {
+		backslashes++;
+		cursor--;
+	}
+	return backslashes % 2 === 1;
+}
+function isIndentWhitespace(ch) {
+	return ch === " " || ch === "	";
+}
+function advanceMarkdownIndentColumn(column, ch) {
+	return ch === " " ? column + 1 : column + 4 - column % 4;
+}
+function getMarkdownIndent(line) {
+	let index = 0;
+	let column = 0;
+	while (index < line.length && isIndentWhitespace(line[index])) {
+		column = advanceMarkdownIndentColumn(column, line[index]);
+		index++;
+	}
+	return {
+		index,
+		column
+	};
+}
+function consumeMarkdownIndent(line) {
+	const indent = getMarkdownIndent(line);
+	return indent.column > 3 ? null : indent;
+}
+function parseMarkdownFenceMarker(line) {
+	const indent = consumeMarkdownIndent(line);
+	if (!indent) return null;
+	const index = indent.index;
+	const markerChar = line[index];
+	if (markerChar !== "`" && markerChar !== "~") return null;
+	let markerEnd = index;
+	while (markerEnd < line.length && line[markerEnd] === markerChar) markerEnd++;
+	const markerLen = markerEnd - index;
+	if (markerLen < 3) return null;
+	const rest = line.slice(markerEnd);
+	if (markerChar === "`" && rest.includes("`")) return null;
+	return {
+		markerChar,
+		markerLen,
+		rest
+	};
+}
+function stripMarkdownListPrefix(line) {
+	const indent = consumeMarkdownIndent(line);
+	if (!indent) return null;
+	const rest = line.slice(indent.index);
+	const marker = /^(?:[-+*]|\d{1,9}[.)])(?=[\t ]|$)/.exec(rest)?.[0];
+	if (!marker) return null;
+	let index = indent.index + marker.length;
+	let column = indent.column + marker.length;
+	if (!isIndentWhitespace(line[index])) return null;
+	while (index < line.length && isIndentWhitespace(line[index])) {
+		column = advanceMarkdownIndentColumn(column, line[index]);
+		index++;
+	}
+	return {
+		content: line.slice(index),
+		contentIndent: column
+	};
+}
+function stripMarkdownBlockquotePrefix(line) {
+	let rest = line;
+	let saw = false;
+	while (true) {
+		const indent = consumeMarkdownIndent(rest);
+		if (!indent) return saw ? rest : null;
+		let index = indent.index;
+		if (rest[index] !== ">") return saw ? rest : null;
+		saw = true;
+		index++;
+		if (rest[index] === " " || rest[index] === "	") index++;
+		rest = rest.slice(index);
+	}
+}
+function matchMarkdownFenceMarker(line) {
+	const direct = parseMarkdownFenceMarker(line);
+	if (direct) return {
+		...direct,
+		inBlockquote: false,
+		inList: false,
+		listIndent: 0
+	};
+	const quoted = stripMarkdownBlockquotePrefix(line);
+	const quotedMarker = quoted == null ? null : parseMarkdownFenceMarker(quoted);
+	if (quotedMarker) return {
+		...quotedMarker,
+		inBlockquote: true,
+		inList: false,
+		listIndent: 0
+	};
+	const listed = stripMarkdownListPrefix(line);
+	if (!listed) return null;
+	const listedMarker = parseMarkdownFenceMarker(listed.content);
+	return listedMarker == null ? null : {
+		...listedMarker,
+		inBlockquote: false,
+		inList: true,
+		listIndent: listed.contentIndent
+	};
+}
+function countRepeatedChar(source, index, ch) {
+	let end = index;
+	while (end < source.length && source[end] === ch) end++;
+	return end - index;
+}
+function findCodeSpanCloseIndex(line, start, markerLen) {
+	let index = start;
+	while (index < line.length) {
+		const next = line.indexOf("`", index);
+		if (next === -1) return -1;
+		const runLen = countRepeatedChar(line, next, "`");
+		if (runLen === markerLen) return next;
+		index = next + runLen;
+	}
+	return -1;
+}
+function resetExplicitBracketFenceContext(context) {
+	context.inFence = false;
+	context.fenceChar = "";
+	context.fenceLen = 0;
+	context.fenceInBlockquote = false;
+	context.fenceInList = false;
+	context.fenceListIndent = 0;
+}
+function scanLineForExplicitBracketMathState(line, context, lineStart, appendStart, openAtAppendStart) {
+	let index = 0;
+	let closedOpenMath = false;
+	while (index < line.length) {
+		const sourceIndex = index;
+		if (context.inMath) {
+			if (line.startsWith("\\]", index) && !isEscapedDelimiterAt(line, sourceIndex)) {
+				if (appendStart != null && openAtAppendStart && lineStart + index + 2 > appendStart) closedOpenMath = true;
+				context.inMath = false;
+				index += 2;
+				continue;
+			}
+			index++;
+			continue;
+		}
+		if (line[index] === "`" && !isEscapedDelimiterAt(line, sourceIndex)) {
+			const markerLen = countRepeatedChar(line, index, "`");
+			const closeIndex = findCodeSpanCloseIndex(line, index + markerLen, markerLen);
+			if (closeIndex === -1) break;
+			index = closeIndex + markerLen;
+			continue;
+		}
+		if (line.startsWith("\\[", index) && !isEscapedDelimiterAt(line, sourceIndex)) {
+			context.inMath = true;
+			index += 2;
+			continue;
+		}
+		index++;
+	}
+	return closedOpenMath;
+}
+function scanExplicitBracketMathLine(line, context, lineStart, appendStart, openAtAppendStart) {
+	const lineIndent = getMarkdownIndent(line);
+	const listPrefix = stripMarkdownListPrefix(line);
+	if (context.inFence && context.fenceInBlockquote && line.trim() && stripMarkdownBlockquotePrefix(line) == null) resetExplicitBracketFenceContext(context);
+	if (context.inFence && context.fenceInList && line.trim() && lineIndent.column < context.fenceListIndent && !listPrefix) resetExplicitBracketFenceContext(context);
+	if (listPrefix) context.listContentIndent = listPrefix.contentIndent;
+	else if (line.trim() && context.listContentIndent != null && lineIndent.column < context.listContentIndent && !context.inFence) context.listContentIndent = null;
+	if (!context.inMath) {
+		const fenceMatch = matchMarkdownFenceMarker(line);
+		if (fenceMatch) if (context.inFence) {
+			if (fenceMatch.markerChar === context.fenceChar && fenceMatch.markerLen >= context.fenceLen && /^\s*$/.test(fenceMatch.rest)) resetExplicitBracketFenceContext(context);
+		} else {
+			context.inFence = true;
+			context.fenceChar = fenceMatch.markerChar;
+			context.fenceLen = fenceMatch.markerLen;
+			context.fenceInBlockquote = fenceMatch.inBlockquote;
+			context.fenceInList = fenceMatch.inList || context.listContentIndent != null && !fenceMatch.inBlockquote && lineIndent.column >= context.listContentIndent;
+			context.fenceListIndent = fenceMatch.listIndent || context.listContentIndent || 0;
+		}
+		else if (!context.inFence) return scanLineForExplicitBracketMathState(line, context, lineStart, appendStart, openAtAppendStart);
+	} else return scanLineForExplicitBracketMathState(line, context, lineStart, appendStart, openAtAppendStart);
+	return false;
+}
+function scanExplicitBracketMathStreamState(source, initialContext = createExplicitBracketMathContext(), appendStart = null, openAtAppendStart = false) {
+	const context = cloneExplicitBracketMathContext(initialContext);
+	let committedContext = cloneExplicitBracketMathContext(initialContext);
+	let lineBuffer = "";
+	let closedOpenMath = false;
+	let index = 0;
+	while (index < source.length) {
+		const newlineIndex = source.indexOf("\n", index);
+		const hasNewline = newlineIndex !== -1;
+		const lineEnd$2 = hasNewline && newlineIndex > index && source[newlineIndex - 1] === "\r" ? newlineIndex - 1 : hasNewline ? newlineIndex : source.length;
+		const line = source.slice(index, lineEnd$2);
+		if (scanExplicitBracketMathLine(line, context, index, appendStart, openAtAppendStart)) closedOpenMath = true;
+		if (hasNewline) {
+			committedContext = cloneExplicitBracketMathContext(context);
+			lineBuffer = "";
+		} else lineBuffer = line;
+		index = hasNewline ? newlineIndex + 1 : source.length;
+	}
+	return {
+		closedOpenMath,
+		state: {
+			committedContext,
+			context,
+			lineBuffer
+		}
+	};
+}
+function updateExplicitBracketMathStreamState(previous, appended) {
+	if (appended && !previous.context.inMath && !previous.context.inFence && !previous.committedContext.inFence && !/[\\`~\r\n]/.test(appended) && !(previous.lineBuffer.endsWith("\\") && (appended[0] === "[" || appended[0] === "]"))) return {
+		closedOpenMath: false,
+		state: {
+			committedContext: cloneExplicitBracketMathContext(previous.committedContext),
+			context: cloneExplicitBracketMathContext(previous.context),
+			lineBuffer: previous.lineBuffer + appended
+		}
+	};
+	return scanExplicitBracketMathStreamState(previous.lineBuffer + appended, previous.committedContext, previous.lineBuffer.length, previous.context.inMath);
+}
 function syncTolerantMathBoundaryStreamCache(md, source) {
 	if (!hasMarkstreamMathPlugin(md)) return;
 	const stream = md.stream;
@@ -18061,18 +18475,22 @@ function syncTolerantMathBoundaryStreamCache(md, source) {
 	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)) {
+	const sourceExtendsPrevious = previous ? source.startsWith(previous.source) : false;
+	const appended = sourceExtendsPrevious && previous ? source.slice(previous.source.length) : "";
+	const explicitBracketMathUpdate = sourceExtendsPrevious && previous ? updateExplicitBracketMathStreamState(previous.explicitBracketMath, appended) : scanExplicitBracketMathStreamState(source);
+	const nextExplicitBracketMath = explicitBracketMathUpdate.state;
+	const completesExplicitBracketMathClose = sourceExtendsPrevious && previous ? explicitBracketMathUpdate.closedOpenMath : false;
+	if (previous && sourceExtendsPrevious) {
+		if (previous.key === null && previous.pendingCandidate === false && !completesExplicitBracketMathClose && !appendedChunkMayAffectTolerantMathBoundary(previous.source, appended) && !sourceEndsWithSplitTolerantBoundaryPrefix(source)) {
 			previous.source = source;
+			previous.explicitBracketMath = nextExplicitBracketMath;
 			return;
 		}
 	}
 	const nextKey = getTolerantMathBlockBoundaryStreamKey(source);
-	const sourceWasReplaced = previous ? !source.startsWith(previous.source) : false;
-	if (previous && (sourceWasReplaced || previous.key !== nextKey)) stream.reset();
+	if (previous && ((previous ? !sourceExtendsPrevious : false) || previous.key !== nextKey || completesExplicitBracketMathClose)) stream.reset();
 	else if (!previous && nextKey) stream.reset();
-	setTolerantMathBoundaryStreamCache(md, source, nextKey);
+	setTolerantMathBoundaryStreamCache(md, source, nextKey, nextExplicitBracketMath);
 }
 function shouldCloneTopLevelStreamTokens(options) {
 	return typeof options.preTransformTokens === "function" || typeof options.postTransformTokens === "function";
@@ -18141,6 +18559,10 @@ function buildParagraphFromInlineChildren(children) {
 		raw: children.map(stringifyInlineNodeRaw).join("")
 	};
 }
+function inheritSourceMap(nodes, sourceNode) {
+	if (!sourceNode.sourceMap) return;
+	for (const node of nodes) if (!node.sourceMap) node.sourceMap = sourceNode.sourceMap;
+}
 function maybePromoteCustomNodeFromParagraph(node, options) {
 	if (node.type !== "paragraph") return null;
 	const nodeChildren = getNodeFields(node).children;
@@ -18480,7 +18902,7 @@ function combineStructuredDetailsHtmlBlocks(nodes, source, md, options, final, s
 		const renderedCloseRaw = explicitClose ? source.slice(closeStart, closeSliceEnd) : closeRaw;
 		const mergedRaw = explicitClose ? source.slice(openStart, closeSliceEnd) : source.slice(openStart);
 		const contentPrefix = selfContained && openTagEndIndex !== -1 ? openRaw.slice(0, openTagEndIndex + 1) : openRaw;
-		merged.push({
+		const detailsNode = {
 			...node,
 			tag: "details",
 			attrs: parseTagAttrs(openRaw.slice(0, openTagEndIndex + 1)),
@@ -18488,14 +18910,16 @@ function combineStructuredDetailsHtmlBlocks(nodes, source, md, options, final, s
 			content: `${contentPrefix}${renderedMiddle}${renderedCloseRaw}`,
 			children: [...prefixChildren, ...children],
 			loading: !final && !explicitClose
-		});
+		};
+		if (options.includeSourceMap) detailsNode.sourceMap = createSourceMapFromOffsets(source, openStart, explicitClose ? closeSliceEnd : source.length, options);
+		merged.push(detailsNode);
 		cursor = explicitClose ? closeSliceEnd : source.length;
 		if (closeIndex === -1 && !selfContained) break;
 		if (closeIndex !== -1) i = closeIndex;
 	}
 	return [merged, cursor];
 }
-function mergeSplitTopLevelHtmlBlocks(nodes, final, source) {
+function mergeSplitTopLevelHtmlBlocks(nodes, final, source, options) {
 	if (!source) return nodes;
 	const merged = nodes.slice();
 	let sourceHtmlCursor = 0;
@@ -18528,6 +18952,7 @@ function mergeSplitTopLevelHtmlBlocks(nodes, final, source) {
 		node.raw = exact.raw;
 		node.loading = desiredLoading;
 		node.attrs = exactAttrs.length ? exactAttrs : void 0;
+		if (options?.includeSourceMap) node.sourceMap = createSourceMapFromOffsets(source, exact.start, exact.end, options);
 		if (!needsExpansion) continue;
 		let tailCursor = findApproximateConsumedPrefixEnd(exact.raw, currentRaw);
 		if (tailCursor === -1) tailCursor = 0;
@@ -18694,6 +19119,106 @@ function stripDanglingHtmlLikeTail(markdown) {
 	if (!isLikelyHtmlTagPrefix(tail)) return s;
 	return s.slice(0, lastLt);
 }
+function createSourceLineMapper(source, parsedSource) {
+	if (source === parsedSource) return void 0;
+	const sourceLines = source.split(/\r?\n/);
+	const parsedLines = parsedSource.split(/\r?\n/);
+	const mappedLines = [];
+	let sourceCursor = 0;
+	for (let parsedLine = 0; parsedLine < parsedLines.length; parsedLine++) {
+		const line = parsedLines[parsedLine] ?? "";
+		if (sourceLines[sourceCursor] === line) {
+			mappedLines[parsedLine] = {
+				startLine: sourceCursor,
+				endLine: sourceCursor + 1
+			};
+			sourceCursor++;
+			continue;
+		}
+		const sourceLine = sourceLines[sourceCursor] ?? "";
+		if (line !== "" && sourceLine !== line && sourceLine.startsWith(line)) {
+			let joinedLine = line;
+			let splitEnd = -1;
+			for (let nextParsedLine = parsedLine + 1; nextParsedLine < parsedLines.length; nextParsedLine++) {
+				joinedLine += parsedLines[nextParsedLine] ?? "";
+				if (joinedLine === sourceLine) {
+					splitEnd = nextParsedLine;
+					break;
+				}
+				if (!sourceLine.startsWith(joinedLine)) break;
+			}
+			if (splitEnd !== -1) {
+				for (let mappedLine = parsedLine; mappedLine <= splitEnd; mappedLine++) mappedLines[mappedLine] = {
+					startLine: sourceCursor,
+					endLine: sourceCursor + 1
+				};
+				sourceCursor++;
+				parsedLine = splitEnd;
+				continue;
+			}
+			mappedLines[parsedLine] = {
+				startLine: sourceCursor,
+				endLine: sourceCursor + 1
+			};
+			continue;
+		}
+		let collapsedLine = sourceLines[sourceCursor] ?? "";
+		let collapsedEnd = -1;
+		for (let sourceLine$1 = sourceCursor + 1; sourceLine$1 < sourceLines.length; sourceLine$1++) {
+			collapsedLine += `\\n${sourceLines[sourceLine$1] ?? ""}`;
+			if (collapsedLine === line) {
+				collapsedEnd = sourceLine$1 + 1;
+				break;
+			}
+			if (!line.startsWith(collapsedLine)) break;
+		}
+		if (collapsedEnd !== -1) {
+			mappedLines[parsedLine] = {
+				startLine: sourceCursor,
+				endLine: collapsedEnd
+			};
+			sourceCursor = collapsedEnd;
+			continue;
+		}
+		let found = -1;
+		if (line !== "") {
+			const searchEnd = Math.min(sourceLines.length, sourceCursor + 80);
+			for (let sourceLine$1 = sourceCursor; sourceLine$1 < searchEnd; sourceLine$1++) if (sourceLines[sourceLine$1] === line) {
+				found = sourceLine$1;
+				break;
+			}
+		}
+		if (found !== -1) {
+			mappedLines[parsedLine] = {
+				startLine: found,
+				endLine: found + 1
+			};
+			sourceCursor = found + 1;
+			continue;
+		}
+		const fallbackLine = Math.min(Math.max(0, sourceLines.length - 1), Math.max(0, sourceCursor - 1));
+		mappedLines[parsedLine] = {
+			startLine: fallbackLine,
+			endLine: fallbackLine + 1
+		};
+	}
+	return (line) => {
+		const index = Number.isFinite(line) ? Math.max(0, Math.trunc(line)) : 0;
+		if (index < mappedLines.length) return mappedLines[index] ?? {
+			startLine: 0,
+			endLine: 0
+		};
+		const lastMapped = mappedLines[mappedLines.length - 1] ?? {
+			startLine: Math.max(0, sourceLines.length - 1),
+			endLine: sourceLines.length
+		};
+		const startLine = Math.min(sourceLines.length, lastMapped.endLine + index - mappedLines.length);
+		return {
+			startLine,
+			endLine: Math.min(sourceLines.length, startLine + 1)
+		};
+	};
+}
 function ensureBlankLineBeforeInlineMultilineCustomHtmlBlocks(markdown, tags) {
 	if (!markdown || !tags.length) return markdown;
 	const tagSet = new Set(tags.map((t) => String(t ?? "").toLowerCase()).filter(Boolean));
@@ -19315,7 +19840,8 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 	const timing = getParseTiming(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");
+	const sourceMarkdown = (markdown ?? "").toString();
+	let safeMarkdown = sourceMarkdown.replace(/([^\\])\r(ight|ho)/g, "$1\\r$2").replace(/([^\\])\r?\n(abla|eq|ot|exists)/g, "$1\\n$2");
 	if (shouldResetTopLevelStreamCacheForFinalAutoParse(md, options)) {
 		md.stream.reset();
 		clearTolerantMathBoundaryStreamCache(md);
@@ -19358,6 +19884,13 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 	if (!isFinal) safeMarkdown = stripDanglingHtmlLikeTail(safeMarkdown);
 	const standaloneHtmlDocument = parseStandaloneHtmlDocument(safeMarkdown);
 	if (standaloneHtmlDocument) {
+		if (options.includeSourceMap) {
+			const sourceMapOptions = {
+				...options,
+				__sourceLineMapper: createSourceLineMapper(sourceMarkdown, safeMarkdown)
+			};
+			standaloneHtmlDocument[0].sourceMap = createSourceMapFromOffsets(safeMarkdown, 0, safeMarkdown.length, sourceMapOptions);
+		}
 		const preHook = options.preTransformTokens;
 		const postHook = options.postTransformTokens;
 		if (shouldUseTopLevelStreamParse(md, options) || typeof preHook === "function" || typeof postHook === "function") {
@@ -19365,10 +19898,10 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 			const hookedTokens = typeof preHook === "function" ? preHook(rawTokens) || rawTokens : rawTokens;
 			if (typeof postHook === "function") postHook(hookedTokens);
 		}
-		return finishTimedParse(standaloneHtmlDocument, timing, parseStartedAt);
+		return finishParsedNodes(standaloneHtmlDocument, options, timing, parseStartedAt);
 	}
 	const tokens = parseTopLevelTokens(md, safeMarkdown, { __markstreamFinal: isFinal }, options);
-	if (!tokens || !Array.isArray(tokens)) return finishTimedParse([], timing, parseStartedAt);
+	if (!tokens || !Array.isArray(tokens)) return finishParsedNodes([], options, timing, parseStartedAt);
 	const pre = options.preTransformTokens;
 	const post = options.postTransformTokens;
 	let transformedTokens = tokens;
@@ -19379,6 +19912,7 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 		...options,
 		validateLink: validateLink$1,
 		__markdownIt: md,
+		__sourceLineMapper: options.includeSourceMap === true ? createSourceLineMapper(sourceMarkdown, safeMarkdown) : void 0,
 		__sourceMarkdown: safeMarkdown,
 		__customHtmlBlockCursor: 0
 	};
@@ -19388,13 +19922,16 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 		if (Array.isArray(postResult)) {
 			const first = postResult[0];
 			const firstType = first?.type;
-			if (first && typeof firstType === "string") result = processTokensWithTiming(postResult, void 0, timing);
+			if (first && typeof firstType === "string") result = processTokensWithTiming(postResult, {
+				...internalOptions,
+				__customHtmlBlockCursor: 0
+			}, timing);
 			else result = postResult;
 		}
 	}
-	result = mergeSplitTopLevelHtmlBlocks(result, isFinal, safeMarkdown);
-	result = combineStructuredDetailsHtmlBlocks(result, safeMarkdown, md, options, isFinal)[0];
-	result = structureGenericHtmlBlockChildren(result, md, options, isFinal);
+	result = mergeSplitTopLevelHtmlBlocks(result, isFinal, safeMarkdown, internalOptions);
+	result = combineStructuredDetailsHtmlBlocks(result, safeMarkdown, md, internalOptions, isFinal)[0];
+	result = structureGenericHtmlBlockChildren(result, md, internalOptions, isFinal);
 	if (isFinal) {
 		const seen = /* @__PURE__ */ new WeakSet();
 		const finalizeHtmlBlockLoading = (value) => {
@@ -19411,6 +19948,7 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 		};
 		finalizeHtmlBlockLoading(result);
 	}
+	result = applyPostTransformNodes(result, options);
 	if (options.debug) console.log("Parsed Markdown Tree Structure:", result);
 	return finishTimedParse(result, timing, parseStartedAt);
 }
@@ -19418,6 +19956,7 @@ function processTokens(tokens, options) {
 	if (!tokens || !Array.isArray(tokens)) return [];
 	const result = [];
 	const linkifyContext = createLinkifyDemotionContextTracker(options);
+	const includeSourceMap = options?.includeSourceMap === true;
 	let i = 0;
 	while (i < tokens.length) {
 		const handled = parseCommonBlockToken(tokens, i, linkifyContext.options(), containerTokenHandlers);
@@ -19432,9 +19971,12 @@ function processTokens(tokens, options) {
 			case "paragraph_open": {
 				const paragraphRaw = String(tokens[i + 1]?.content ?? "");
 				const paragraphNode = parseParagraph(tokens, i, linkifyContext.options(paragraphRaw));
+				if (includeSourceMap) applyNodeSourceMap(paragraphNode, token, options);
 				const promoted = maybePromoteCustomNodeFromParagraph(paragraphNode, options);
-				if (promoted) result.push(...promoted);
-				else result.push(paragraphNode);
+				if (promoted) {
+					if (includeSourceMap) inheritSourceMap(promoted, paragraphNode);
+					result.push(...promoted);
+				} else result.push(paragraphNode);
 				linkifyContext.remember(paragraphNode.raw);
 				i += 3;
 				break;
@@ -19442,6 +19984,7 @@ function processTokens(tokens, options) {
 			case "bullet_list_open":
 			case "ordered_list_open": {
 				const [listNode, newIndex] = parseList(tokens, i, linkifyContext.options());
+				if (includeSourceMap) applyNodeSourceMap(listNode, token, options);
 				result.push(listNode);
 				linkifyContext.remember(listNode.raw);
 				i = newIndex;
@@ -19449,6 +19992,7 @@ function processTokens(tokens, options) {
 			}
 			case "blockquote_open": {
 				const [blockquoteNode, newIndex] = parseBlockquote(tokens, i, linkifyContext.options());
+				if (includeSourceMap) applyNodeSourceMap(blockquoteNode, token, options);
 				result.push(blockquoteNode);
 				linkifyContext.remember(blockquoteNode.raw);
 				i = newIndex;
@@ -19456,12 +20000,13 @@ function processTokens(tokens, options) {
 			}
 			case "footnote_anchor": {
 				const meta = token.meta ?? {};
-				const id = String(meta.label ?? token.content ?? "");
-				result.push({
+				const footnoteAnchorNode = {
 					type: "footnote_anchor",
-					id,
+					id: String(meta.label ?? token.content ?? ""),
 					raw: String(token.content ?? "")
-				});
+				};
+				if (includeSourceMap) applyNodeSourceMap(footnoteAnchorNode, token, options);
+				result.push(footnoteAnchorNode);
 				linkifyContext.remember(String(token.content ?? ""));
 				i++;
 				break;
@@ -19473,7 +20018,7 @@ function processTokens(tokens, options) {
 				break;
 			case "text": {
 				const content = String(token.content ?? "");
-				result.push({
+				const paragraphNode = {
 					type: "paragraph",
 					raw: content,
 					children: content ? [{
@@ -19481,7 +20026,9 @@ function processTokens(tokens, options) {
 						content,
 						raw: content
 					}] : []
-				});
+				};
+				if (includeSourceMap) applyNodeSourceMap(paragraphNode, token, options);
+				result.push(paragraphNode);
 				linkifyContext.remember(content);
 				i++;
 				break;
@@ -19490,16 +20037,21 @@ function processTokens(tokens, options) {
 				{
 					const raw = String(token.content ?? "");
 					const parsed = parseInlineTokens(token.children || [], raw, void 0, linkifyContext.options(raw));
-					if (parsed.length === 0) {} else if (parsed.every((n) => n.type === "html_block")) result.push(...parsed);
-					else {
+					if (parsed.length === 0) {} else if (parsed.every((n) => n.type === "html_block")) {
+						if (includeSourceMap) for (const node of parsed) applyNodeSourceMap(node, token, options);
+						result.push(...parsed);
+					} else {
 						const paragraphNode = {
 							type: "paragraph",
 							raw,
 							children: parsed
 						};
+						if (includeSourceMap) applyNodeSourceMap(paragraphNode, token, options);
 						const promoted = maybePromoteCustomNodeFromParagraph(paragraphNode, options);
-						if (promoted) result.push(...promoted);
-						else result.push(paragraphNode);
+						if (promoted) {
+							if (includeSourceMap) inheritSourceMap(promoted, paragraphNode);
+							result.push(...promoted);
+						} else result.push(paragraphNode);
 					}
 					linkifyContext.remember(raw);
 				}
@@ -19515,6 +20067,7 @@ function processTokens(tokens, options) {
 
 //#endregion
 //#region src/htmlRenderUtils.ts
+const HTML_TOKEN_TAG_NAME_RE = /^([a-z][\w-]*)(?=[\t\n\f\r />]|$)/i;
 const SAFE_BLOCKED_HTML_TAGS = new Set([
 	...BLOCKED_HTML_TAGS,
 	"base",
@@ -19588,7 +20141,6 @@ const SAFE_ALLOWED_HTML_TAGS = new Set([
 	"tr",
 	"ul"
 ]);
-const CUSTOM_TAG_REGEX = /<([a-z][a-z0-9-]*)\b[^>]*>/gi;
 function hasOwn(obj, key) {
 	return Object.prototype.hasOwnProperty.call(obj, key);
 }
@@ -19626,6 +20178,18 @@ function serializeAttrs(attrs) {
 	if (pairs.length === 0) return "";
 	return pairs.map(([name, value]) => value === "" ? ` ${name}` : ` ${name}="${escapeAttr(value)}"`).join("");
 }
+function parseHtmlTokenTag(rawContent) {
+	const isClosing = rawContent.startsWith("/");
+	const source = isClosing ? rawContent.slice(1) : rawContent;
+	const match = source.match(HTML_TOKEN_TAG_NAME_RE);
+	if (!match) return null;
+	return {
+		attrsStr: isClosing ? "" : source.slice(match[0].length).trimStart(),
+		isClosing,
+		isSelfClosing: !isClosing && rawContent.trimEnd().endsWith("/"),
+		tagName: match[1]
+	};
+}
 function isUnsafeSrcset(value, tagName) {
 	const candidates = value.split(",").map((candidate) => candidate.trim()).filter(Boolean);
 	if (candidates.length === 0) return false;
@@ -19798,37 +20362,34 @@ function tokenizeHtml(html) {
 		}
 		const tagEnd = html.indexOf(">", tagStart);
 		if (tagEnd === -1) break;
-		const tagContent = html.slice(tagStart + 1, tagEnd).trim();
-		const isClosingTag$1 = tagContent.startsWith("/");
-		const isSelfClosing$1 = tagContent.endsWith("/");
-		if (isClosingTag$1) {
-			const tagName = tagContent.slice(1).trim();
-			tokens.push({
-				type: "tag_close",
-				tagName
+		const parsedTag = parseHtmlTokenTag(html.slice(tagStart + 1, tagEnd));
+		if (!parsedTag) {
+			const rawTag = html.slice(tagStart, tagEnd + 1);
+			if (isMeaningfulText(rawTag)) tokens.push({
+				type: "text",
+				content: rawTag
 			});
-		} else {
-			const spaceIndex = tagContent.indexOf(" ");
-			let tagName;
-			let attrsStr = "";
-			if (spaceIndex === -1) tagName = isSelfClosing$1 ? tagContent.slice(0, -1).trim() : tagContent.trim();
-			else {
-				tagName = tagContent.slice(0, spaceIndex).trim();
-				attrsStr = tagContent.slice(spaceIndex + 1);
-			}
+			pos = tagEnd + 1;
+			continue;
+		}
+		if (parsedTag.isClosing) tokens.push({
+			type: "tag_close",
+			tagName: parsedTag.tagName
+		});
+		else {
 			const attrs = {};
-			if (attrsStr) {
+			if (parsedTag.attrsStr) {
 				const attrRegex = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|(\S*)))?/g;
 				let attrMatch;
-				while ((attrMatch = attrRegex.exec(attrsStr)) !== null) {
+				while ((attrMatch = attrRegex.exec(parsedTag.attrsStr)) !== null) {
 					const name = attrMatch[1];
 					const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
 					if (name && !name.endsWith("/")) attrs[name] = value;
 				}
 			}
 			tokens.push({
-				type: isSelfClosing$1 || VOID_HTML_TAGS.has(tagName.toLowerCase()) ? "self_closing" : "tag_open",
-				tagName,
+				type: parsedTag.isSelfClosing || VOID_HTML_TAGS.has(parsedTag.tagName.toLowerCase()) ? "self_closing" : "tag_open",
+				tagName: parsedTag.tagName,
 				attrs
 			});
 		}
@@ -19882,43 +20443,36 @@ function tokenizeHtmlPreservingText(html) {
 		}
 		const tagEnd = html.indexOf(">", tagStart);
 		if (tagEnd === -1) break;
-		const tagContent = html.slice(tagStart + 1, tagEnd).trim();
-		if (!tagContent) {
+		const parsedTag = parseHtmlTokenTag(html.slice(tagStart + 1, tagEnd));
+		if (!parsedTag) {
+			tokens.push({
+				type: "text",
+				content: html.slice(tagStart, tagEnd + 1)
+			});
 			pos = tagEnd + 1;
 			continue;
 		}
-		const isClosingTag$1 = tagContent.startsWith("/");
-		const isSelfClosing$1 = tagContent.endsWith("/");
-		if (isClosingTag$1) {
-			const tagName$1 = tagContent.slice(1).trim();
+		if (parsedTag.isClosing) {
 			tokens.push({
 				type: "tag_close",
-				tagName: tagName$1
+				tagName: parsedTag.tagName
 			});
 			pos = tagEnd + 1;
 			continue;
 		}
-		const spaceIndex = tagContent.indexOf(" ");
-		let tagName = "";
-		let attrsStr = "";
-		if (spaceIndex === -1) tagName = isSelfClosing$1 ? tagContent.slice(0, -1).trim() : tagContent.trim();
-		else {
-			tagName = tagContent.slice(0, spaceIndex).trim();
-			attrsStr = tagContent.slice(spaceIndex + 1);
-		}
 		const attrs = {};
-		if (attrsStr) {
+		if (parsedTag.attrsStr) {
 			const attrRegex = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|(\S*)))?/g;
 			let attrMatch;
-			while ((attrMatch = attrRegex.exec(attrsStr)) !== null) {
+			while ((attrMatch = attrRegex.exec(parsedTag.attrsStr)) !== null) {
 				const name = attrMatch[1];
 				const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
 				if (name && !name.endsWith("/")) attrs[name] = value;
 			}
 		}
 		tokens.push({
-			type: isSelfClosing$1 || VOID_HTML_TAGS.has(tagName.toLowerCase()) ? "self_closing" : "tag_open",
-			tagName,
+			type: parsedTag.isSelfClosing || VOID_HTML_TAGS.has(parsedTag.tagName.toLowerCase()) ? "self_closing" : "tag_open",
+			tagName: parsedTag.tagName,
 			attrs
 		});
 		pos = tagEnd + 1;
@@ -19935,9 +20489,7 @@ function serializeLiteralHtmlTag(token) {
 function hasCustomHtmlComponents(content, customComponents) {
 	if (!content || !content.includes("<")) return false;
 	if (!customComponents || Object.keys(customComponents).length === 0) return false;
-	CUSTOM_TAG_REGEX.lastIndex = 0;
-	let match;
-	while ((match = CUSTOM_TAG_REGEX.exec(content)) !== null) if (isCustomHtmlComponentTag(match[1], customComponents)) return true;
+	for (const token of tokenizeHtml(content)) if ((token.type === "tag_open" || token.type === "self_closing") && isCustomHtmlComponentTag(token.tagName ?? "", customComponents)) return true;
 	return false;
 }
 function sanitizeHtmlContent(content, policy = "safe") {