stream-markdown-parser 0.0.33 → 0.0.35

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.2-beta.8/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.9/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.2-beta.8/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.9/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -5708,12 +5708,10 @@ var Renderer = class {
 	rules;
 	baseOptions;
 	normalizedBase;
-	bufferPool;
 	constructor(options = {}) {
 		this.baseOptions = { ...options };
 		this.normalizedBase = this.buildNormalizedBase();
 		this.rules = { ...defaultRules };
-		this.bufferPool = [];
 	}
 	set(options) {
 		this.baseOptions = {
@@ -5723,65 +5721,54 @@ var Renderer = class {
 		this.normalizedBase = this.buildNormalizedBase();
 		return this;
 	}
-	render(tokens, options = {}, env = {}) {
+	render(tokens, options, env) {
 		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
+		const envRef = env ?? {};
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				this.pushInlineTokens(token.children || [], merged, env, chunks);
+				output += this.renderInlineTokens(token.children || [], merged, envRef);
 				continue;
 			}
 			const rule = this.rules[token.type];
-			if (rule) chunks.push(ensureSyncResult(rule(tokens, i, merged, env, this), token.type));
-			else chunks.push(this.renderToken(tokens, i, merged));
+			if (rule) output += ensureSyncResult(rule(tokens, i, merged, envRef, this), token.type);
+			else output += this.renderToken(tokens, i, merged);
 		}
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
 		return output;
 	}
-	async renderAsync(tokens, options = {}, env = {}) {
+	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 chunks = this.acquireBuffer();
+		const envRef = env ?? {};
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				await this.pushInlineTokensAsync(token.children || [], merged, env, chunks);
+				output += await this.renderInlineTokensAsync(token.children || [], merged, envRef);
 				continue;
 			}
 			const rule = this.rules[token.type];
-			if (rule) chunks.push(await resolveResult(rule(tokens, i, merged, env, this)));
-			else chunks.push(this.renderToken(tokens, i, merged));
+			if (rule) output += await resolveResult(rule(tokens, i, merged, envRef, this));
+			else output += this.renderToken(tokens, i, merged);
 		}
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
 		return output;
 	}
-	renderInline(tokens, options = {}, env = {}) {
+	renderInline(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		this.pushInlineTokens(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineTokens(tokens, merged, envRef);
 	}
-	async renderInlineAsync(tokens, options = {}, env = {}) {
+	async renderInlineAsync(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		await this.pushInlineTokensAsync(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineTokensAsync(tokens, merged, envRef);
 	}
-	renderInlineAsText(tokens, options = {}, env = {}) {
+	renderInlineAsText(tokens, options, env) {
 		const merged = this.mergeOptions(options);
-		const chunks = this.acquireBuffer();
-		this.renderInlineAsTextInternal(tokens, merged, env, chunks);
-		const output = chunks.join("");
-		this.releaseBuffer(chunks);
-		return output;
+		const envRef = env ?? {};
+		return this.renderInlineAsTextInternal(tokens, merged, envRef);
 	}
 	renderAttrs(token) {
 		if (!token.attrs || token.attrs.length === 0) return "";
@@ -5841,56 +5828,53 @@ var Renderer = class {
 			...this.baseOptions
 		});
 	}
-	pushInlineTokens(tokens, options, env, buffer) {
+	renderInlineTokens(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			const rule = this.rules[token.type];
-			if (rule) buffer.push(ensureSyncResult(rule(tokens, i, options, env, this), token.type));
-			else buffer.push(this.renderToken(tokens, i, options));
+			if (rule) output += ensureSyncResult(rule(tokens, i, options, env, this), token.type);
+			else output += this.renderToken(tokens, i, options);
 		}
+		return output;
 	}
-	async pushInlineTokensAsync(tokens, options, env, buffer) {
+	async renderInlineTokensAsync(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			const rule = this.rules[token.type];
-			if (rule) buffer.push(await resolveResult(rule(tokens, i, options, env, this)));
-			else buffer.push(this.renderToken(tokens, i, options));
+			if (rule) output += await resolveResult(rule(tokens, i, options, env, this));
+			else output += this.renderToken(tokens, i, options);
 		}
+		return output;
 	}
-	renderInlineAsTextInternal(tokens, options, env, buffer) {
+	renderInlineAsTextInternal(tokens, options, env) {
+		if (!tokens || tokens.length === 0) return "";
+		let output = "";
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			switch (token.type) {
 				case "text":
 				case "text_special":
-					buffer.push(token.content);
+					output += token.content;
 					break;
 				case "image":
-					this.renderInlineAsTextInternal(token.children || [], options, env, buffer);
+					output += this.renderInlineAsTextInternal(token.children || [], options, env);
 					break;
 				case "html_inline":
 				case "html_block":
-					buffer.push(token.content);
+					output += token.content;
 					break;
 				case "softbreak":
 				case "hardbreak":
-					buffer.push("\n");
+					output += "\n";
 					break;
 				default: break;
 			}
 		}
-	}
-	acquireBuffer() {
-		const buf = this.bufferPool.pop();
-		if (buf) {
-			buf.length = 0;
-			return buf;
-		}
-		return [];
-	}
-	releaseBuffer(buffer) {
-		buffer.length = 0;
-		this.bufferPool.push(buffer);
+		return output;
 	}
 };
 var renderer_default = Renderer;
@@ -7273,7 +7257,6 @@ function fixLinkToken(tokens) {
 			i -= replacerTokens.length - 1;
 			continue;
 		} else if (curToken.content?.startsWith("](") && tokens[i - 1].type === "strong_close" && tokens[i - 4]?.type === "text" && tokens[i - 4]?.content?.includes("**[")) {
-			i++;
 			const replacerTokens = [];
 			const beforeText = tokens[i - 4].content.split("**[")[0];
 			if (beforeText) replacerTokens.push(textToken(beforeText));
@@ -7787,7 +7770,14 @@ const WORDS_RE = /\b(?:sin|cos|tan|log|ln|exp|sqrt|frac|sum|lim|int|prod)\b/;
 const DATE_TIME_RE = /\b\d{4}\/\d{1,2}\/\d{1,2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?\b/;
 function isMathLike(s) {
 	if (!s) return false;
-	const norm = s.replace(/\u0008/g, "\\b");
+	const norm = s.replace(/[\u0008\v\f]/g, (ch) => {
+		switch (ch) {
+			case "\b": return "\\b";
+			case "\v": return "\\v";
+			case "\f": return "\\f";
+			default: return ch;
+		}
+	});
 	const stripped = norm.trim();
 	if (DATE_TIME_RE.test(stripped)) return false;
 	if (stripped.includes("**")) return false;
@@ -8040,7 +8030,7 @@ function applyMath(md, mathOpts) {
 				}
 				foundAny = true;
 				if (!silent) {
-					const before = src.slice(0, index);
+					const before = src.slice(s.pos - s.pending.length, index);
 					let toPushBefore = src.slice(0, searchPos) ? src.slice(preMathPos, index) : before;
 					const isStrongPrefix = countUnescapedStrong(toPushBefore) % 2 === 1;
 					if (index !== s.pos && isStrongPrefix) toPushBefore = s.pending + src.slice(s.pos, index);
@@ -8446,6 +8436,10 @@ function parseHtmlInlineCodeToken(token, tokens, i) {
 		const m = html.match(/>([\s\S]*?)<\s*\/\s*[\w-]+>/);
 		return m ? m[1] : "";
 	}
+	if (tag === "br") return [{
+		type: "hardbreak",
+		raw: code$1
+	}, i + 1];
 	if (tag === "a") {
 		let loading = false;
 		if (!nextToken || nextToken?.type === "text" && (!nnextToken || nnextToken.type !== "html_inline") || !nextToken) loading = true;
@@ -8599,11 +8593,13 @@ function parseLinkToken(tokens, startIndex, options) {
 //#endregion
 //#region src/parser/inline-parsers/math-inline-parser.ts
 function parseMathInlineToken(token) {
+	const content = token.content ?? "";
+	const raw = token.raw === "$$" ? `$${content}$` : token.raw || "";
 	return {
 		type: "math_inline",
-		content: String(token.content ?? ""),
+		content,
 		loading: !!token.loading,
-		raw: token.raw
+		raw
 	};
 }
 
@@ -9561,31 +9557,6 @@ function normalizeSingleLinkResult(raw, nodes) {
 	return nodes;
 }
 
-//#endregion
-//#region src/parser/node-parsers/blockquote-parser.ts
-function parseBlockquote(tokens, index, options) {
-	const blockquoteChildren = [];
-	let j = index + 1;
-	while (j < tokens.length && tokens[j].type !== "blockquote_close") if (tokens[j].type === "paragraph_open") {
-		const contentToken = tokens[j + 1];
-		blockquoteChildren.push({
-			type: "paragraph",
-			children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, { requireClosingStrong: options?.requireClosingStrong }),
-			raw: String(contentToken.content ?? "")
-		});
-		j += 3;
-	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
-		const [listNode, newIndex] = parseList(tokens, j);
-		blockquoteChildren.push(listNode);
-		j = newIndex;
-	} else j++;
-	return [{
-		type: "blockquote",
-		children: blockquoteChildren,
-		raw: blockquoteChildren.map((child) => child.raw).join("\n")
-	}, j + 1];
-}
-
 //#endregion
 //#region src/parser/node-parsers/code-block-parser.ts
 function parseCodeBlock(token) {
@@ -9687,14 +9658,70 @@ function parseHeading(tokens, index, options) {
 	};
 }
 
+//#endregion
+//#region src/parser/node-parsers/html-block-parser.ts
+const VOID_TAGS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const CLOSE_TAG_RE_CACHE = /* @__PURE__ */ new Map();
+function parseHtmlBlock(token) {
+	const raw = String(token.content ?? "");
+	if (/^\s*<!--/.test(raw) || /^\s*<!/.test(raw) || /^\s*<\?/.test(raw)) return {
+		type: "html_block",
+		content: raw,
+		raw,
+		tag: "",
+		loading: false
+	};
+	const tag = (raw.match(/^\s*<([A-Z][\w:-]*)/i)?.[1] || "").toLowerCase();
+	if (!tag) return {
+		type: "html_block",
+		content: raw,
+		raw,
+		tag: "",
+		loading: false
+	};
+	const selfClosing = /^\s*<[^>]*\/\s*>/.test(raw);
+	const isVoid = VOID_TAGS.has(tag);
+	let closeRe = CLOSE_TAG_RE_CACHE.get(tag);
+	if (!closeRe) {
+		closeRe = new RegExp(`<\\/\\s*${tag}\\b`, "i");
+		CLOSE_TAG_RE_CACHE.set(tag, closeRe);
+	}
+	const hasClosing = closeRe.test(raw);
+	const loading = !(isVoid || selfClosing || hasClosing);
+	return {
+		type: "html_block",
+		content: loading ? `${raw.replace(/<[^>]*$/, "")}\n</${tag}>` : raw,
+		raw,
+		tag,
+		loading
+	};
+}
+
 //#endregion
 //#region src/parser/node-parsers/math-block-parser.ts
 function parseMathBlock(token) {
+	const content = String(token.content ?? "");
+	const raw = token.raw === "$$" ? `$$${content}$$` : String(token.raw ?? "");
 	return {
 		type: "math_block",
-		content: String(token.content ?? ""),
+		content,
 		loading: !!token.loading,
-		raw: String(token.raw ?? "")
+		raw
 	};
 }
 
@@ -9775,6 +9802,57 @@ function parseThematicBreak() {
 	};
 }
 
+//#endregion
+//#region src/parser/node-parsers/block-token-parser.ts
+function parseBasicBlockToken(tokens, index, options) {
+	const token = tokens[index];
+	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 "html_block": return [parseHtmlBlock(token), index + 1];
+		case "table_open": {
+			const [tableNode, newIndex] = parseTable(tokens, index, options);
+			return [tableNode, newIndex];
+		}
+		case "dl_open": {
+			const [definitionListNode, newIndex] = parseDefinitionList(tokens, index, options);
+			return [definitionListNode, newIndex];
+		}
+		case "footnote_open": {
+			const [footnoteNode, newIndex] = parseFootnote(tokens, index, options);
+			return [footnoteNode, newIndex];
+		}
+		case "hr": return [parseThematicBreak(), index + 1];
+		default: break;
+	}
+	return null;
+}
+function parseCommonBlockToken(tokens, index, options, handlers) {
+	const basicResult = parseBasicBlockToken(tokens, index, options);
+	if (basicResult) return basicResult;
+	switch (tokens[index].type) {
+		case "container_warning_open":
+		case "container_info_open":
+		case "container_note_open":
+		case "container_tip_open":
+		case "container_danger_open":
+		case "container_caution_open":
+		case "container_error_open":
+			if (handlers?.parseContainer) return handlers.parseContainer(tokens, index, options);
+			break;
+		case "container_open":
+			if (handlers?.matchAdmonition) {
+				const result = handlers.matchAdmonition(tokens, index, options);
+				if (result) return result;
+			}
+			break;
+		default: break;
+	}
+	return null;
+}
+
 //#endregion
 //#region src/parser/node-parsers/list-parser.ts
 function parseList(tokens, index, options) {
@@ -9799,49 +9877,20 @@ function parseList(tokens, index, options) {
 			});
 			k += 3;
 		} else if (tokens[k].type === "blockquote_open") {
-			const [blockquoteNode, newIndex] = parseBlockquote(tokens, k);
+			const [blockquoteNode, newIndex] = parseBlockquote(tokens, k, options);
 			itemChildren.push(blockquoteNode);
 			k = newIndex;
 		} else if (tokens[k].type === "bullet_list_open" || tokens[k].type === "ordered_list_open") {
-			const [nestedListNode, newIndex] = parseNestedList(tokens, k, options);
+			const [nestedListNode, newIndex] = parseList(tokens, k, options);
 			itemChildren.push(nestedListNode);
 			k = newIndex;
-		} else if (tokens[k].type === "code_block") {
-			itemChildren.push(parseCodeBlock(tokens[k]));
-			k += 1;
-		} else if (tokens[k].type === "fence") {
-			itemChildren.push(parseFenceToken(tokens[k]));
-			k += 1;
-		} else if (tokens[k].type === "math_block") {
-			itemChildren.push(parseMathBlock(tokens[k]));
-			k += 1;
-		} else if (tokens[k].type === "table_open") {
-			const [tableNode, newIndex] = parseTable(tokens, k);
-			itemChildren.push(tableNode);
-			k = newIndex;
-		} else if (tokens[k].type === "dl_open") {
-			const [defListNode, newIndex] = parseDefinitionList(tokens, k);
-			itemChildren.push(defListNode);
-			k = newIndex;
-		} else if (tokens[k].type === "footnote_open") {
-			const [footnoteNode, newIndex] = parseFootnote(tokens, k);
-			itemChildren.push(footnoteNode);
-			k = newIndex;
-		} else if (tokens[k].type === "heading_open") {
-			const headingNode = parseHeading(tokens, k);
-			itemChildren.push(headingNode);
-			k += 3;
-		} else if (tokens[k].type === "hr") {
-			itemChildren.push(parseThematicBreak());
-			k += 1;
-		} else if (tokens[k].type === "container_open") {
-			const match = /^::: ?(warning|info|note|tip|danger|caution) ?(.*)$/.exec(String(tokens[k].info ?? ""));
-			if (match) {
-				const [admonitionNode, newIndex] = parseAdmonition(tokens, k, match);
-				itemChildren.push(admonitionNode);
-				k = newIndex;
+		} else {
+			const handled = parseCommonBlockToken(tokens, k, options, containerTokenHandlers);
+			if (handled) {
+				itemChildren.push(handled[0]);
+				k = handled[1];
 			} else k += 1;
-		} else k += 1;
+		}
 		listItems.push({
 			type: "list_item",
 			children: itemChildren,
@@ -9865,59 +9914,6 @@ function parseList(tokens, index, options) {
 		raw: listItems.map((item) => item.raw).join("\n")
 	}, j + 1];
 }
-function parseNestedList(tokens, index, options) {
-	const nestedToken = tokens[index];
-	const nestedItems = [];
-	let j = index + 1;
-	while (j < tokens.length && tokens[j].type !== "bullet_list_close" && tokens[j].type !== "ordered_list_close") if (tokens[j].type === "list_item_open") {
-		const itemChildren = [];
-		let k = j + 1;
-		while (k < tokens.length && tokens[k].type !== "list_item_close") if (tokens[k].type === "paragraph_open") {
-			const contentToken = tokens[k + 1];
-			const preToken = tokens[k - 1];
-			itemChildren.push({
-				type: "paragraph",
-				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), preToken, { requireClosingStrong: options?.requireClosingStrong }),
-				raw: String(contentToken.content ?? "")
-			});
-			k += 3;
-		} else if (tokens[k].type === "bullet_list_open" || tokens[k].type === "ordered_list_open") {
-			const [deeperNestedListNode, newIndex] = parseNestedList(tokens, k, options);
-			itemChildren.push(deeperNestedListNode);
-			k = newIndex;
-		} else if (tokens[k].type === "code_block") {
-			itemChildren.push(parseCodeBlock(tokens[k]));
-			k += 1;
-		} else if (tokens[k].type === "fence") {
-			itemChildren.push(parseFenceToken(tokens[k]));
-			k += 1;
-		} else if (tokens[k].type === "math_block") {
-			itemChildren.push(parseMathBlock(tokens[k]));
-			k += 1;
-		} else k += 1;
-		nestedItems.push({
-			type: "list_item",
-			children: itemChildren,
-			raw: itemChildren.map((child) => child.raw).join("")
-		});
-		j = k + 1;
-	} else j += 1;
-	return [{
-		type: "list",
-		ordered: nestedToken.type === "ordered_list_open",
-		start: (() => {
-			if (nestedToken.attrs && nestedToken.attrs.length) {
-				const found = nestedToken.attrs.find((a) => a[0] === "start");
-				if (found) {
-					const parsed = Number(found[1]);
-					return Number.isFinite(parsed) && parsed !== 0 ? parsed : 1;
-				}
-			}
-		})(),
-		items: nestedItems,
-		raw: nestedItems.map((item) => item.raw).join("\n")
-	}, j + 1];
-}
 
 //#endregion
 //#region src/parser/node-parsers/admonition-parser.ts
@@ -9938,7 +9934,17 @@ function parseAdmonition(tokens, index, match, options) {
 		const [listNode, newIndex] = parseList(tokens, j, options);
 		admonitionChildren.push(listNode);
 		j = newIndex;
-	} else j++;
+	} else if (tokens[j].type === "blockquote_open") {
+		const [blockquoteNode, newIndex] = parseBlockquote(tokens, j, options);
+		admonitionChildren.push(blockquoteNode);
+		j = newIndex;
+	} else {
+		const handled = parseBasicBlockToken(tokens, j, options);
+		if (handled) {
+			admonitionChildren.push(handled[0]);
+			j = handled[1];
+		} else j++;
+	}
 	return [{
 		type: "admonition",
 		kind,
@@ -9998,7 +10004,17 @@ function parseContainer(tokens, index, options) {
 		const [listNode, newIndex] = parseList(tokens, j, options);
 		children.push(listNode);
 		j = newIndex;
-	} else j++;
+	} else if (tokens[j].type === "blockquote_open") {
+		const [blockquoteNode, newIndex] = parseBlockquote(tokens, j, options);
+		children.push(blockquoteNode);
+		j = newIndex;
+	} else {
+		const handled = parseBasicBlockToken(tokens, j, options);
+		if (handled) {
+			children.push(handled[0]);
+			j = handled[1];
+		} else j++;
+	}
 	return [{
 		type: "admonition",
 		kind,
@@ -10008,6 +10024,66 @@ function parseContainer(tokens, index, options) {
 	}, j + 1];
 }
 
+//#endregion
+//#region src/parser/node-parsers/container-token-handlers.ts
+const CONTAINER_REGEX = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/;
+function handleContainerOpen(tokens, index, options) {
+	const token = tokens[index];
+	if (token.type !== "container_open") return null;
+	const match = CONTAINER_REGEX.exec(String(token.info ?? ""));
+	if (!match) return null;
+	return parseAdmonition(tokens, index, match, options);
+}
+const containerTokenHandlers = {
+	parseContainer: (tokens, index, options) => parseContainer(tokens, index, options),
+	matchAdmonition: handleContainerOpen
+};
+
+//#endregion
+//#region src/parser/node-parsers/blockquote-parser.ts
+function parseBlockquote(tokens, index, options) {
+	const blockquoteChildren = [];
+	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];
+			blockquoteChildren.push({
+				type: "paragraph",
+				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, { requireClosingStrong: options?.requireClosingStrong }),
+				raw: String(contentToken.content ?? "")
+			});
+			j += 3;
+			break;
+		}
+		case "bullet_list_open":
+		case "ordered_list_open": {
+			const [listNode, newIndex] = parseList(tokens, j, options);
+			blockquoteChildren.push(listNode);
+			j = newIndex;
+			break;
+		}
+		case "blockquote_open": {
+			const [nestedBlockquote, newIndex] = parseBlockquote(tokens, j, options);
+			blockquoteChildren.push(nestedBlockquote);
+			j = newIndex;
+			break;
+		}
+		default: {
+			const handled = parseCommonBlockToken(tokens, j, options, containerTokenHandlers);
+			if (handled) {
+				blockquoteChildren.push(handled[0]);
+				j = handled[1];
+			} else j++;
+			break;
+		}
+	}
+	return [{
+		type: "blockquote",
+		children: blockquoteChildren,
+		raw: blockquoteChildren.map((child) => child.raw).join("\n")
+	}, j + 1];
+}
+
 //#endregion
 //#region src/parser/node-parsers/hardbreak-parser.ts
 function parseHardBreak() {
@@ -10017,60 +10093,6 @@ function parseHardBreak() {
 	};
 }
 
-//#endregion
-//#region src/parser/node-parsers/html-block-parser.ts
-const VOID_TAGS = new Set([
-	"area",
-	"base",
-	"br",
-	"col",
-	"embed",
-	"hr",
-	"img",
-	"input",
-	"link",
-	"meta",
-	"param",
-	"source",
-	"track",
-	"wbr"
-]);
-const CLOSE_TAG_RE_CACHE = /* @__PURE__ */ new Map();
-function parseHtmlBlock(token) {
-	const raw = String(token.content ?? "");
-	if (/^\s*<!--/.test(raw) || /^\s*<!/.test(raw) || /^\s*<\?/.test(raw)) return {
-		type: "html_block",
-		content: raw,
-		raw,
-		tag: "",
-		loading: false
-	};
-	const tag = (raw.match(/^\s*<([A-Z][\w:-]*)/i)?.[1] || "").toLowerCase();
-	if (!tag) return {
-		type: "html_block",
-		content: raw,
-		raw,
-		tag: "",
-		loading: false
-	};
-	const selfClosing = /^\s*<[^>]*\/\s*>/.test(raw);
-	const isVoid = VOID_TAGS.has(tag);
-	let closeRe = CLOSE_TAG_RE_CACHE.get(tag);
-	if (!closeRe) {
-		closeRe = new RegExp(`<\\/\\s*${tag}\\b`, "i");
-		CLOSE_TAG_RE_CACHE.set(tag, closeRe);
-	}
-	const hasClosing = closeRe.test(raw);
-	const loading = !(isVoid || selfClosing || hasClosing);
-	return {
-		type: "html_block",
-		content: loading ? `${raw.replace(/<[^>]*$/, "")}\n</${tag}>` : raw,
-		raw,
-		tag,
-		loading
-	};
-}
-
 //#endregion
 //#region src/parser/node-parsers/paragraph-parser.ts
 function parseParagraph(tokens, index, options) {
@@ -10113,40 +10135,18 @@ function processTokens(tokens, options) {
 	const result = [];
 	let i = 0;
 	while (i < tokens.length) {
+		const handled = parseCommonBlockToken(tokens, i, options, containerTokenHandlers);
+		if (handled) {
+			result.push(handled[0]);
+			i = handled[1];
+			continue;
+		}
 		const token = tokens[i];
 		switch (token.type) {
-			case "container_warning_open":
-			case "container_info_open":
-			case "container_note_open":
-			case "container_tip_open":
-			case "container_danger_open":
-			case "container_caution_open":
-			case "container_error_open": {
-				const [warningNode, newIndex] = parseContainer(tokens, i, options);
-				result.push(warningNode);
-				i = newIndex;
-				break;
-			}
-			case "heading_open":
-				result.push(parseHeading(tokens, i, options));
-				i += 3;
-				break;
 			case "paragraph_open":
 				result.push(parseParagraph(tokens, i, options));
 				i += 3;
 				break;
-			case "html_block":
-				result.push(parseHtmlBlock(token));
-				i += 1;
-				break;
-			case "code_block":
-				result.push(parseCodeBlock(tokens[i]));
-				i += 1;
-				break;
-			case "fence":
-				result.push(parseFenceToken(tokens[i]));
-				i += 1;
-				break;
 			case "bullet_list_open":
 			case "ordered_list_open": {
 				const [listNode, newIndex] = parseList(tokens, i, options);
@@ -10154,34 +10154,12 @@ function processTokens(tokens, options) {
 				i = newIndex;
 				break;
 			}
-			case "hr":
-				result.push(parseThematicBreak());
-				i += 1;
-				break;
 			case "blockquote_open": {
 				const [blockquoteNode, newIndex] = parseBlockquote(tokens, i, options);
 				result.push(blockquoteNode);
 				i = newIndex;
 				break;
 			}
-			case "table_open": {
-				const [tableNode, newIndex] = parseTable(tokens, i, options);
-				result.push(tableNode);
-				i = newIndex;
-				break;
-			}
-			case "dl_open": {
-				const [definitionListNode, newIndex] = parseDefinitionList(tokens, i, options);
-				result.push(definitionListNode);
-				i = newIndex;
-				break;
-			}
-			case "footnote_open": {
-				const [footnoteNode, newIndex] = parseFootnote(tokens, i, options);
-				result.push(footnoteNode);
-				i = newIndex;
-				break;
-			}
 			case "footnote_anchor": {
 				const meta = token.meta ?? {};
 				const id = String(meta.label ?? token.content ?? "");
@@ -10193,23 +10171,10 @@ function processTokens(tokens, options) {
 				i++;
 				break;
 			}
-			case "container_open": {
-				const match = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(String(token.info ?? ""));
-				if (match) {
-					const [admonitionNode, newIndex] = parseAdmonition(tokens, i, match, options);
-					result.push(admonitionNode);
-					i = newIndex;
-				} else i += 1;
-				break;
-			}
 			case "hardbreak":
 				result.push(parseHardBreak());
 				i++;
 				break;
-			case "math_block":
-				result.push(parseMathBlock(tokens[i]));
-				i += 1;
-				break;
 			case "inline":
 				result.push(...parseInlineTokens(token.children || [], String(token.content ?? ""), void 0, { requireClosingStrong: options?.requireClosingStrong }));
 				i += 1;