@orkestrel/markdown 0.0.5 → 0.0.6

package/dist/src/core/index.js

@@ -862,15 +862,6 @@ function scanInline(source, from, to, depth = 0) {
 	const nodes = [];
 	let index = from;
 	let pending = "";
-	const flush = () => {
-		if (pending.length > 0) {
-			nodes.push({
-				element: "text",
-				value: pending
-			});
-			pending = "";
-		}
-	};
 	while (index < to) {
 		const character = source[index] ?? "";
 		if (character === "\\" && index + 1 < to && isEscapable(source[index + 1] ?? "")) {
@@ -878,40 +869,51 @@ function scanInline(source, from, to, depth = 0) {
 			index += 2;
 			continue;
 		}
+		let scanned;
+		let end = index;
 		if (character === "`") {
 			const span = scanCode(source, index, to);
 			if (span) {
-				flush();
-				nodes.push({
+				scanned = {
 					element: "codeSpan",
 					value: span.value
-				});
-				index = span.end;
-				continue;
+				};
+				end = span.end;
 			}
 		}
 		if (character === "[") {
 			const link = scanLink(source, index, to, depth);
 			if (link) {
-				flush();
-				nodes.push(link.node);
-				index = link.end;
-				continue;
+				scanned = link.node;
+				end = link.end;
 			}
 		}
 		if (character === "*" || character === "_") {
 			const emphasis = scanEmphasis(source, index, to, depth);
 			if (emphasis) {
-				flush();
-				nodes.push(emphasis.node);
-				index = emphasis.end;
-				continue;
+				scanned = emphasis.node;
+				end = emphasis.end;
 			}
 		}
+		if (scanned !== void 0) {
+			if (pending.length > 0) {
+				nodes.push({
+					element: "text",
+					value: pending
+				});
+				pending = "";
+			}
+			nodes.push(scanned);
+			index = end;
+			continue;
+		}
 		pending += character;
 		index += 1;
 	}
-	flush();
+	if (pending.length > 0) nodes.push({
+		element: "text",
+		value: pending
+	});
 	return nodes;
 }
 /**
@@ -970,10 +972,7 @@ function sanitizeUrl(href) {
 * @remarks
 * Total: never throws. At {@link MAX_DEPTH} a value-bearing node (`text` / `codeSpan`)
 * degrades to its escaped `value`; any other node degrades to `''` instead of
-* recursing further, so pathologically deep input cannot exhaust the call stack. The
-* recursive engine and its per-shape sub-steps (inline concatenation, table cell,
-* tight list-item) are nested inner functions - the only exported surface is
-* `renderHTML` itself.
+* recursing further, so pathologically deep input cannot exhaust the call stack.
 *
 * @param node - The AST node to render (a full document, or any sub-node)
 * @returns The rendered, XSS-safe HTML string
@@ -987,47 +986,158 @@ function sanitizeUrl(href) {
 * ```
 */
 function renderHTML(node) {
-	function render(current, depth) {
-		if (depth >= 64) return "value" in current && typeof current.value === "string" ? escapeHtml(current.value) : "";
+	const stack = [{
+		node,
+		depth: 0,
+		expanded: false,
+		count: 0
+	}];
+	const values = [];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0) continue;
+		const current = frame.node;
+		if (!frame.expanded) {
+			if (frame.depth >= 64) {
+				values.push("value" in current && typeof current.value === "string" ? escapeHtml(current.value) : "");
+				continue;
+			}
+			const children = [];
+			let depth = frame.depth + 1;
+			switch (current.element) {
+				case "document":
+				case "heading":
+				case "paragraph":
+				case "blockquote":
+					for (const child of current.children) if (child !== void 0) children.push(child);
+					break;
+				case "listItem": {
+					const only = current.children[0];
+					if (current.children.length === 1 && only !== void 0 && only.element === "paragraph") {
+						for (const child of only.children) if (child !== void 0) children.push(child);
+					} else for (const child of current.children) if (child !== void 0) children.push(child);
+					break;
+				}
+				case "emphasis":
+				case "link":
+					for (const child of current.children) if (child !== void 0) children.push(child);
+					depth += 1;
+					break;
+				case "list":
+					for (const child of current.items) if (child !== void 0) children.push(child);
+					break;
+				case "table":
+					for (const cell of current.header) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+					for (const row of current.rows) if (row !== void 0) {
+						for (const cell of row) if (cell !== void 0) {
+							for (const child of cell) if (child !== void 0) children.push(child);
+						}
+					}
+					depth += 1;
+					break;
+			}
+			stack.push({
+				...frame,
+				expanded: true,
+				count: children.length
+			});
+			for (let index = children.length - 1; index >= 0; index -= 1) {
+				const child = children[index];
+				if (child !== void 0) stack.push({
+					node: child,
+					depth,
+					expanded: false,
+					count: 0
+				});
+			}
+			continue;
+		}
+		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
+		let value = "";
 		switch (current.element) {
-			case "document": return current.children.map((child) => render(child, depth + 1)).join("\n");
-			case "heading": return `<h${current.level}>${renderInline(current.children, depth)}</h${current.level}>`;
-			case "paragraph": return `<p>${renderInline(current.children, depth)}</p>`;
-			case "thematicBreak": return "<hr>";
-			case "blockquote": return `<blockquote>\n${current.children.map((child) => render(child, depth + 1)).join("\n")}\n</blockquote>`;
-			case "codeBlock": return `<pre>${current.lang === void 0 ? "<code>" : `<code class="language-${escapeHtml(current.lang)}">`}${escapeHtml(current.code)}</code></pre>`;
+			case "document":
+				value = children.join("\n");
+				break;
+			case "heading":
+				value = `<h${current.level}>${children.join("")}</h${current.level}>`;
+				break;
+			case "paragraph":
+				value = `<p>${children.join("")}</p>`;
+				break;
+			case "thematicBreak":
+				value = "<hr>";
+				break;
+			case "blockquote":
+				value = `<blockquote>\n${children.join("\n")}\n</blockquote>`;
+				break;
+			case "codeBlock":
+				value = `<pre>${current.lang === void 0 ? "<code>" : `<code class="language-${escapeHtml(current.lang)}">`}${escapeHtml(current.code)}</code></pre>`;
+				break;
 			case "list": {
-				const items = current.items.map((item) => render(item, depth + 1)).join("\n");
-				if (!current.ordered) return `<ul>\n${items}\n</ul>`;
-				return `<ol${current.start !== 1 ? ` start="${current.start}"` : ""}>\n${items}\n</ol>`;
+				const items = children.join("\n");
+				if (!current.ordered) {
+					value = `<ul>\n${items}\n</ul>`;
+					break;
+				}
+				value = `<ol${current.start !== 1 ? ` start="${current.start}"` : ""}>\n${items}\n</ol>`;
+				break;
 			}
-			case "listItem": return `<li>${renderItem(current.children, depth)}</li>`;
+			case "listItem":
+				value = `<li>${children.join(current.children.length === 1 && current.children[0]?.element === "paragraph" ? "" : "\n")}</li>`;
+				break;
 			case "table": {
-				const head = `<tr>${current.header.map((cell, column) => renderCell("th", cell, current.align[column], depth)).join("")}</tr>`;
-				const body = current.rows.map((row) => `<tr>${row.map((cell, column) => renderCell("td", cell, current.align[column], depth)).join("")}</tr>`).join("\n");
-				return `<table>\n<thead>\n${head}\n</thead>${isNonEmptyArray(current.rows) ? `\n<tbody>\n${body}\n</tbody>` : ""}\n</table>`;
+				let offset = 0;
+				const header = [];
+				for (const [column, cell] of current.header.entries()) {
+					if (cell === void 0) continue;
+					const align = current.align[column];
+					const style = align === "left" || align === "right" || align === "center" ? ` style="text-align:${align}"` : "";
+					let count = 0;
+					for (const child of cell) if (child !== void 0) count += 1;
+					header.push(`<th${style}>${children.slice(offset, offset + count).join("")}</th>`);
+					offset += count;
+				}
+				const rows = [];
+				for (const row of current.rows) {
+					const cells = [];
+					for (const [column, cell] of row.entries()) {
+						if (cell === void 0) continue;
+						const align = current.align[column];
+						const style = align === "left" || align === "right" || align === "center" ? ` style="text-align:${align}"` : "";
+						let count = 0;
+						for (const child of cell) if (child !== void 0) count += 1;
+						cells.push(`<td${style}>${children.slice(offset, offset + count).join("")}</td>`);
+						offset += count;
+					}
+					rows.push(`<tr>${cells.join("")}</tr>`);
+				}
+				const body = rows.join("\n");
+				const bodyHtml = isNonEmptyArray(current.rows) ? `\n<tbody>\n${body}\n</tbody>` : "";
+				value = `<table>\n<thead>\n<tr>${header.join("")}</tr>\n</thead>${bodyHtml}\n</table>`;
+				break;
 			}
-			case "text": return escapeHtml(current.value);
-			case "emphasis": return current.strong ? `<strong>${renderInline(current.children, depth + 1)}</strong>` : `<em>${renderInline(current.children, depth + 1)}</em>`;
-			case "codeSpan": return `<code>${escapeHtml(current.value)}</code>`;
-			case "link": return `<a href="${sanitizeUrl(current.href)}">${renderInline(current.children, depth + 1)}</a>`;
-			default: return "";
-		}
-	}
-	function renderInline(nodes, depth) {
-		return nodes.map((child) => render(child, depth + 1)).join("");
-	}
-	function renderCell(tag, cell, align, depth) {
-		return `<${tag}${align === "left" || align === "right" || align === "center" ? ` style="text-align:${align}"` : ""}>${renderInline(cell, depth + 1)}</${tag}>`;
-	}
-	function renderItem(children, depth) {
-		if (children.length === 1) {
-			const only = children[0];
-			if (only !== void 0 && only.element === "paragraph") return renderInline(only.children, depth);
+			case "text":
+				value = escapeHtml(current.value);
+				break;
+			case "emphasis":
+				value = current.strong ? `<strong>${children.join("")}</strong>` : `<em>${children.join("")}</em>`;
+				break;
+			case "codeSpan":
+				value = `<code>${escapeHtml(current.value)}</code>`;
+				break;
+			case "link":
+				value = `<a href="${sanitizeUrl(current.href)}">${children.join("")}</a>`;
+				break;
+			default:
+				value = "";
+				break;
 		}
-		return children.map((child) => render(child, depth + 1)).join("\n");
+		if (stack.length === 0) return value;
+		values.push(value);
 	}
-	return render(node, 0);
+	return "";
 }
 /**
 * Render a {@link MarkdownNode} to its CANONICAL markdown source - the inverse
@@ -1057,125 +1167,220 @@ function renderHTML(node) {
 * ```
 */
 function renderMarkdown(node) {
-	function escapeText(value) {
-		let out = "";
-		for (let index = 0; index < value.length; index += 1) {
-			const character = value[index] ?? "";
-			const atLineStart = index === 0 || value[index - 1] === "\n";
-			if (character === "\\" || character === "*" || character === "_" || character === "`" || character === "[" || character === "]") {
-				out += `\\${character}`;
-				continue;
-			}
-			if (atLineStart) {
-				if (character === "#" || character === ">") {
-					out += `\\${character}`;
+	const stack = [{
+		node,
+		depth: 0,
+		expanded: false,
+		count: 0,
+		escaped: ""
+	}];
+	const values = [];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0) continue;
+		const current = frame.node;
+		if (!frame.expanded) {
+			let escaped = "";
+			if ((frame.depth >= 64 || current.element === "text") && "value" in current && typeof current.value === "string") for (let index = 0; index < current.value.length; index += 1) {
+				const character = current.value[index] ?? "";
+				const atLineStart = index === 0 || current.value[index - 1] === "\n";
+				if (character === "\\" || character === "*" || character === "_" || character === "`" || character === "[" || character === "]") {
+					escaped += `\\${character}`;
 					continue;
 				}
-				if ((character === "-" || character === "+") && (value[index + 1] ?? " ") === " ") {
-					out += `\\${character}`;
-					continue;
-				}
-				if (/[0-9]/.test(character)) {
-					let end = index;
-					while (end < value.length && /[0-9]/.test(value[end] ?? "")) end += 1;
-					const marker = value[end];
-					if ((marker === "." || marker === ")") && value[end + 1] === " ") {
-						out += `${value.slice(index, end)}\\${marker}`;
-						index = end;
+				if (atLineStart) {
+					if (character === "#" || character === ">") {
+						escaped += `\\${character}`;
+						continue;
+					}
+					if ((character === "-" || character === "+") && (current.value[index + 1] ?? " ") === " ") {
+						escaped += `\\${character}`;
 						continue;
 					}
+					if (/[0-9]/.test(character)) {
+						let end = index;
+						while (end < current.value.length && /[0-9]/.test(current.value[end] ?? "")) end += 1;
+						const marker = current.value[end];
+						if ((marker === "." || marker === ")") && current.value[end + 1] === " ") {
+							escaped += `${current.value.slice(index, end)}\\${marker}`;
+							index = end;
+							continue;
+						}
+					}
 				}
+				escaped += character;
+			}
+			if (frame.depth >= 64) {
+				values.push(escaped);
+				continue;
+			}
+			const children = [];
+			let depth = frame.depth + 1;
+			switch (current.element) {
+				case "document":
+				case "heading":
+				case "paragraph":
+				case "blockquote":
+				case "listItem":
+				case "emphasis":
+				case "link":
+					for (const child of current.children) if (child !== void 0) children.push(child);
+					break;
+				case "list":
+					for (const child of current.items) if (child !== void 0) children.push(child);
+					break;
+				case "table":
+					for (const cell of current.header) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+					for (const row of current.rows) {
+						if (row === void 0) continue;
+						for (let column = 0; column < current.header.length; column += 1) {
+							const cell = row[column];
+							if (cell !== void 0) {
+								for (const child of cell) if (child !== void 0) children.push(child);
+							}
+						}
+					}
+					depth += 1;
+					break;
+			}
+			stack.push({
+				...frame,
+				expanded: true,
+				count: children.length,
+				escaped
+			});
+			for (let index = children.length - 1; index >= 0; index -= 1) {
+				const child = children[index];
+				if (child !== void 0) stack.push({
+					node: child,
+					depth,
+					expanded: false,
+					count: 0,
+					escaped: ""
+				});
 			}
-			out += character;
+			continue;
 		}
-		return out;
-	}
-	function fenceFor(body, minimum) {
-		let longest = 0;
-		let run = 0;
-		for (const character of body) if (character === "`") {
-			run += 1;
-			longest = Math.max(longest, run);
-		} else run = 0;
-		return "`".repeat(Math.max(minimum, longest + 1));
-	}
-	function renderInline(nodes, depth) {
-		return nodes.map((child) => render(child, depth + 1)).join("");
-	}
-	function renderBlocks(blocks, depth) {
-		return blocks.map((block) => render(block, depth + 1)).join("\n\n");
-	}
-	function renderItem(item, marker, depth) {
-		const body = renderBlocks(item.children, depth + 1);
-		const pad = " ".repeat(marker.length);
-		return body.split("\n").map((line, index) => index === 0 ? marker + line : line === "" ? "" : pad + line).join("\n");
-	}
-	function renderCell(cell, depth) {
-		return renderInline(cell, depth + 1).replace(/\|/g, "\\|");
-	}
-	function renderTable(current, depth) {
-		const columns = current.header.length;
-		return [
-			`| ${current.header.map((cell) => renderCell(cell, depth)).join(" | ")} |`,
-			`| ${current.align.map((align) => {
-				if (align === "left") return ":--";
-				if (align === "right") return "--:";
-				if (align === "center") return ":-:";
-				return "---";
-			}).join(" | ")} |`,
-			...current.rows.map((row) => {
-				const cells = [];
-				for (let column = 0; column < columns; column += 1) {
-					const cell = row[column];
-					cells.push(cell === void 0 ? "" : renderCell(cell, depth));
-				}
-				return `| ${cells.join(" | ")} |`;
-			})
-		].join("\n");
-	}
-	function render(current, depth) {
-		if (depth >= 64) return "value" in current && typeof current.value === "string" ? escapeText(current.value) : "";
+		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
+		let value = "";
 		switch (current.element) {
-			case "document": return renderBlocks(current.children, depth);
+			case "codeBlock":
+			case "codeSpan": {
+				const body = current.element === "codeBlock" ? current.code : current.value;
+				let longest = 0;
+				let run = 0;
+				for (const character of body) if (character === "`") {
+					run += 1;
+					longest = Math.max(longest, run);
+				} else run = 0;
+				const fence = "`".repeat(Math.max(current.element === "codeBlock" ? 3 : 1, longest + 1));
+				if (current.element === "codeBlock") {
+					value = `${fence}${current.lang === void 0 ? "" : current.lang}\n${current.code}\n${fence}`;
+					break;
+				}
+				const pad = current.value.startsWith("`") || current.value.endsWith("`") ? " " : "";
+				value = `${fence}${pad}${current.value}${pad}${fence}`;
+				break;
+			}
+			case "document":
+				value = children.join("\n\n");
+				break;
 			case "heading": {
-				const escaped = renderInline(current.children, depth).replace(/(^|[^\\])(#+)$/, (_match, pre, hashes) => {
-					return `${pre}\\${hashes[0] ?? ""}${hashes.slice(1)}`;
+				const escaped = children.join("").replace(/(^|[^\\])(#+)$/, (_match, before, hashes) => {
+					return `${before}\\${hashes[0] ?? ""}${hashes.slice(1)}`;
 				});
-				return `${"#".repeat(current.level)} ${escaped}`;
-			}
-			case "paragraph": return renderInline(current.children, depth);
-			case "thematicBreak": return "---";
-			case "blockquote": return renderBlocks(current.children, depth).split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
-			case "codeBlock": {
-				const fence = fenceFor(current.code, 3);
-				return `${fence}${current.lang === void 0 ? "" : current.lang}\n${current.code}\n${fence}`;
+				value = `${"#".repeat(current.level)} ${escaped}`;
+				break;
 			}
+			case "paragraph":
+				value = children.join("");
+				break;
+			case "thematicBreak":
+				value = "---";
+				break;
+			case "blockquote":
+				value = children.join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+				break;
 			case "list": {
+				const items = [];
 				let ordinal = current.start;
-				return current.items.map((item) => {
-					return renderItem(item, current.ordered ? `${ordinal++}. ` : "- ", depth);
-				}).join("\n");
+				for (const body of children) {
+					const marker = current.ordered ? `${ordinal}. ` : "- ";
+					ordinal += 1;
+					const pad = " ".repeat(marker.length);
+					items.push(body.split("\n").map((line, index) => index === 0 ? marker + line : line === "" ? "" : pad + line).join("\n"));
+				}
+				value = items.join("\n");
+				break;
+			}
+			case "listItem":
+				value = children.join("\n\n");
+				break;
+			case "table": {
+				let offset = 0;
+				const header = [];
+				for (const cell of current.header) {
+					if (cell === void 0) {
+						header.push("");
+						continue;
+					}
+					let count = 0;
+					for (const child of cell) if (child !== void 0) count += 1;
+					header.push(children.slice(offset, offset + count).join("").replace(/\|/g, "\\|"));
+					offset += count;
+				}
+				const delimiter = current.align.map((align) => {
+					if (align === "left") return ":--";
+					if (align === "right") return "--:";
+					if (align === "center") return ":-:";
+					return "---";
+				});
+				const rows = [];
+				for (const row of current.rows) {
+					const cells = [];
+					for (let column = 0; column < current.header.length; column += 1) {
+						const cell = row[column];
+						if (cell === void 0) {
+							cells.push("");
+							continue;
+						}
+						let count = 0;
+						for (const child of cell) if (child !== void 0) count += 1;
+						cells.push(children.slice(offset, offset + count).join("").replace(/\|/g, "\\|"));
+						offset += count;
+					}
+					rows.push(`| ${cells.join(" | ")} |`);
+				}
+				value = [
+					`| ${header.join(" | ")} |`,
+					`| ${delimiter.join(" | ")} |`,
+					...rows
+				].join("\n");
+				break;
 			}
-			case "listItem": return renderBlocks(current.children, depth);
-			case "table": return renderTable(current, depth);
-			case "text": return escapeText(current.value);
+			case "text":
+				value = frame.escaped;
+				break;
 			case "emphasis": {
 				const marker = current.strong ? "**" : "*";
-				return `${marker}${renderInline(current.children, depth)}${marker}`;
-			}
-			case "codeSpan": {
-				const fence = fenceFor(current.value, 1);
-				const pad = current.value.startsWith("`") || current.value.endsWith("`") ? " " : "";
-				return `${fence}${pad}${current.value}${pad}${fence}`;
+				value = `${marker}${children.join("")}${marker}`;
+				break;
 			}
 			case "link": {
 				const href = current.href.replace(/[\\()]/g, (character) => `\\${character}`);
-				return `[${renderInline(current.children, depth)}](${href})`;
+				value = `[${children.join("")}](${href})`;
+				break;
 			}
-			default: return "";
+			default:
+				value = "";
+				break;
 		}
+		if (stack.length === 0) return value;
+		values.push(value);
 	}
-	return render(node, 0);
+	return "";
 }
 /**
 * Depth-first, pre-order, root-inclusive traversal of a {@link MarkdownNode} - yields
@@ -1197,10 +1402,17 @@ function renderMarkdown(node) {
 * ```
 */
 function* walkNodes(node) {
-	function* walk(current, depth) {
-		yield current;
-		if (depth >= 64) return;
-		switch (current.element) {
+	const stack = [{
+		node,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0) continue;
+		yield frame.node;
+		if (frame.depth >= 64) continue;
+		const children = [];
+		switch (frame.node.element) {
 			case "document":
 			case "heading":
 			case "paragraph":
@@ -1208,19 +1420,30 @@ function* walkNodes(node) {
 			case "listItem":
 			case "emphasis":
 			case "link":
-				for (const child of current.children) yield* walk(child, depth + 1);
-				return;
+				for (const child of frame.node.children) if (child !== void 0) children.push(child);
+				break;
 			case "list":
-				for (const item of current.items) yield* walk(item, depth + 1);
-				return;
+				for (const child of frame.node.items) if (child !== void 0) children.push(child);
+				break;
 			case "table":
-				for (const cell of current.header) for (const inline of cell) yield* walk(inline, depth + 1);
-				for (const row of current.rows) for (const cell of row) for (const inline of cell) yield* walk(inline, depth + 1);
-				return;
-			default: return;
+				for (const cell of frame.node.header) if (cell !== void 0) {
+					for (const child of cell) if (child !== void 0) children.push(child);
+				}
+				for (const row of frame.node.rows) if (row !== void 0) {
+					for (const cell of row) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+				}
+				break;
+		}
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child !== void 0) stack.push({
+				node: child,
+				depth: frame.depth + 1
+			});
 		}
 	}
-	yield* walk(node, 0);
 }
 /**
 * Fold a {@link MarkdownNode} into a `T` via a total catamorphism - children are
@@ -1254,46 +1477,119 @@ function* walkNodes(node) {
 * ```
 */
 function foldNode(node, handlers, depth) {
-	function dispatch(current, children) {
-		switch (current.element) {
-			case "document": return handlers.document(current, children);
-			case "heading": return handlers.heading(current, children);
-			case "paragraph": return handlers.paragraph(current, children);
-			case "thematicBreak": return handlers.thematicBreak(current, children);
-			case "blockquote": return handlers.blockquote(current, children);
-			case "codeBlock": return handlers.codeBlock(current, children);
-			case "list": return handlers.list(current, children);
-			case "listItem": return handlers.listItem(current, children);
-			case "table": return handlers.table(current, children);
-			case "text": return handlers.text(current, children);
-			case "emphasis": return handlers.emphasis(current, children);
-			case "codeSpan": return handlers.codeSpan(current, children);
-			case "link": return handlers.link(current, children);
+	const stack = [{
+		node,
+		depth,
+		expanded: false,
+		count: 0
+	}];
+	const values = [];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0) continue;
+		if (!frame.expanded) {
+			const children = [];
+			if (frame.depth < 64) switch (frame.node.element) {
+				case "document":
+				case "heading":
+				case "paragraph":
+				case "blockquote":
+				case "listItem":
+				case "emphasis":
+				case "link":
+					for (const child of frame.node.children) if (child !== void 0) children.push(child);
+					break;
+				case "list":
+					for (const child of frame.node.items) if (child !== void 0) children.push(child);
+					break;
+				case "table":
+					for (const cell of frame.node.header) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+					for (const row of frame.node.rows) if (row !== void 0) {
+						for (const cell of row) if (cell !== void 0) {
+							for (const child of cell) if (child !== void 0) children.push(child);
+						}
+					}
+					break;
+			}
+			stack.push({
+				...frame,
+				expanded: true,
+				count: children.length
+			});
+			for (let index = children.length - 1; index >= 0; index -= 1) {
+				const child = children[index];
+				if (child !== void 0) stack.push({
+					node: child,
+					depth: frame.depth + 1,
+					expanded: false,
+					count: 0
+				});
+			}
+			continue;
 		}
-	}
-	function childNodes(current) {
-		switch (current.element) {
+		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
+		let value;
+		switch (frame.node.element) {
 			case "document":
+				value = handlers.document(frame.node, children);
+				break;
 			case "heading":
+				value = handlers.heading(frame.node, children);
+				break;
 			case "paragraph":
+				value = handlers.paragraph(frame.node, children);
+				break;
+			case "thematicBreak":
+				value = handlers.thematicBreak(frame.node, children);
+				break;
 			case "blockquote":
+				value = handlers.blockquote(frame.node, children);
+				break;
+			case "codeBlock":
+				value = handlers.codeBlock(frame.node, children);
+				break;
+			case "list":
+				value = handlers.list(frame.node, children);
+				break;
 			case "listItem":
+				value = handlers.listItem(frame.node, children);
+				break;
+			case "table":
+				value = handlers.table(frame.node, children);
+				break;
+			case "text":
+				value = handlers.text(frame.node, children);
+				break;
 			case "emphasis":
-			case "link": return current.children;
-			case "list": return current.items;
-			case "table": {
-				const header = current.header.flatMap((cell) => cell);
-				const rows = current.rows.flatMap((row) => row.flatMap((cell) => cell));
-				return [...header, ...rows];
-			}
-			default: return [];
+				value = handlers.emphasis(frame.node, children);
+				break;
+			case "codeSpan":
+				value = handlers.codeSpan(frame.node, children);
+				break;
+			case "link":
+				value = handlers.link(frame.node, children);
+				break;
 		}
+		if (stack.length === 0) return value;
+		values.push(value);
 	}
-	function fold(current, level) {
-		if (level >= 64) return dispatch(current, []);
-		return dispatch(current, childNodes(current).map((child) => fold(child, level + 1)));
+	switch (node.element) {
+		case "document": return handlers.document(node, []);
+		case "heading": return handlers.heading(node, []);
+		case "paragraph": return handlers.paragraph(node, []);
+		case "thematicBreak": return handlers.thematicBreak(node, []);
+		case "blockquote": return handlers.blockquote(node, []);
+		case "codeBlock": return handlers.codeBlock(node, []);
+		case "list": return handlers.list(node, []);
+		case "listItem": return handlers.listItem(node, []);
+		case "table": return handlers.table(node, []);
+		case "text": return handlers.text(node, []);
+		case "emphasis": return handlers.emphasis(node, []);
+		case "codeSpan": return handlers.codeSpan(node, []);
+		case "link": return handlers.link(node, []);
 	}
-	return fold(node, depth);
 }
 /**
 * Rewrite a {@link MarkdownDocument} bottom-up (copy-on-write) - each node's children
@@ -1328,71 +1624,227 @@ function foldNode(node, handlers, depth) {
 * ```
 */
 function rewriteDocument(document, rewrite) {
-	function rewriteInline(node, depth) {
-		if (depth >= 64) return node;
-		const rebuilt = rebuildInline(node, depth);
-		const result = rewrite(rebuilt);
-		return isInlineNode(result) ? result : rebuilt;
-	}
-	function rewriteBlock(node, depth) {
-		if (depth >= 64) return node;
-		const rebuilt = rebuildBlock(node, depth);
-		const result = rewrite(rebuilt);
-		return isBlockNode(result) ? result : rebuilt;
-	}
-	function rewriteItem(item, depth) {
-		if (depth >= 64) return item;
-		const rebuilt = {
-			element: "listItem",
-			children: item.children.map((child) => rewriteBlock(child, depth + 1))
-		};
+	const stack = [{
+		node: document,
+		depth: -1,
+		expanded: false,
+		count: 0
+	}];
+	const values = [];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0) continue;
+		const current = frame.node;
+		if (!frame.expanded) {
+			if (current.element !== "document" && frame.depth >= 64) {
+				values.push(current);
+				continue;
+			}
+			const children = [];
+			switch (current.element) {
+				case "document":
+				case "heading":
+				case "paragraph":
+				case "blockquote":
+				case "listItem":
+				case "emphasis":
+				case "link":
+					for (const child of current.children) if (child !== void 0) children.push(child);
+					break;
+				case "list":
+					for (const child of current.items) if (child !== void 0) children.push(child);
+					break;
+				case "table":
+					for (const cell of current.header) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+					for (const row of current.rows) if (row !== void 0) {
+						for (const cell of row) if (cell !== void 0) {
+							for (const child of cell) if (child !== void 0) children.push(child);
+						}
+					}
+					break;
+			}
+			stack.push({
+				...frame,
+				expanded: true,
+				count: children.length
+			});
+			const depth = current.element === "document" ? 0 : frame.depth + 1;
+			for (let index = children.length - 1; index >= 0; index -= 1) {
+				const child = children[index];
+				if (child !== void 0) stack.push({
+					node: child,
+					depth,
+					expanded: false,
+					count: 0
+				});
+			}
+			continue;
+		}
+		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
+		let rebuilt = current;
+		switch (current.element) {
+			case "document": {
+				const blocks = [];
+				let offset = 0;
+				for (const block of current.children) {
+					if (block === void 0) continue;
+					const child = children[offset];
+					blocks.push(child !== void 0 && isBlockNode(child) ? child : block);
+					offset += 1;
+				}
+				const result = {
+					element: "document",
+					children: blocks
+				};
+				if (stack.length === 0) return result;
+				values.push(result);
+				continue;
+			}
+			case "heading":
+			case "paragraph": {
+				const inlines = [];
+				let offset = 0;
+				for (const inline of current.children) {
+					if (inline === void 0) continue;
+					const child = children[offset];
+					inlines.push(child !== void 0 && isInlineNode(child) ? child : inline);
+					offset += 1;
+				}
+				rebuilt = {
+					...current,
+					children: inlines
+				};
+				break;
+			}
+			case "blockquote": {
+				const blocks = [];
+				let offset = 0;
+				for (const block of current.children) {
+					if (block === void 0) continue;
+					const child = children[offset];
+					blocks.push(child !== void 0 && isBlockNode(child) ? child : block);
+					offset += 1;
+				}
+				rebuilt = {
+					...current,
+					children: blocks
+				};
+				break;
+			}
+			case "listItem": {
+				const blocks = [];
+				let offset = 0;
+				for (const block of current.children) {
+					if (block === void 0) continue;
+					const child = children[offset];
+					blocks.push(child !== void 0 && isBlockNode(child) ? child : block);
+					offset += 1;
+				}
+				rebuilt = {
+					element: "listItem",
+					children: blocks
+				};
+				break;
+			}
+			case "emphasis":
+			case "link": {
+				const inlines = [];
+				let offset = 0;
+				for (const inline of current.children) {
+					if (inline === void 0) continue;
+					const child = children[offset];
+					inlines.push(child !== void 0 && isInlineNode(child) ? child : inline);
+					offset += 1;
+				}
+				rebuilt = {
+					...current,
+					children: inlines
+				};
+				break;
+			}
+			case "list": {
+				const items = [];
+				let offset = 0;
+				for (const item of current.items) {
+					if (item === void 0) continue;
+					const child = children[offset];
+					items.push(child?.element === "listItem" ? child : item);
+					offset += 1;
+				}
+				rebuilt = {
+					...current,
+					items
+				};
+				break;
+			}
+			case "table": {
+				let offset = 0;
+				const header = [];
+				for (const cell of current.header) {
+					if (cell === void 0) continue;
+					const inlines = [];
+					for (const inline of cell) {
+						if (inline === void 0) continue;
+						const child = children[offset];
+						inlines.push(child !== void 0 && isInlineNode(child) ? child : inline);
+						offset += 1;
+					}
+					header.push(inlines);
+				}
+				const rows = [];
+				for (const row of current.rows) {
+					if (row === void 0) continue;
+					const cells = [];
+					for (const cell of row) {
+						if (cell === void 0) continue;
+						const inlines = [];
+						for (const inline of cell) {
+							if (inline === void 0) continue;
+							const child = children[offset];
+							inlines.push(child !== void 0 && isInlineNode(child) ? child : inline);
+							offset += 1;
+						}
+						cells.push(inlines);
+					}
+					rows.push(cells);
+				}
+				rebuilt = {
+					...current,
+					header,
+					rows
+				};
+				break;
+			}
+		}
 		const result = rewrite(rebuilt);
-		return result.element === "listItem" ? result : rebuilt;
-	}
-	function rebuildInline(node, depth) {
-		switch (node.element) {
-			case "emphasis": return {
-				...node,
-				children: node.children.map((child) => rewriteInline(child, depth + 1))
-			};
-			case "link": return {
-				...node,
-				children: node.children.map((child) => rewriteInline(child, depth + 1))
-			};
+		let accepted = rebuilt;
+		switch (current.element) {
 			case "text":
-			case "codeSpan": return node;
-		}
-	}
-	function rebuildBlock(node, depth) {
-		switch (node.element) {
-			case "heading": return {
-				...node,
-				children: node.children.map((child) => rewriteInline(child, depth + 1))
-			};
-			case "paragraph": return {
-				...node,
-				children: node.children.map((child) => rewriteInline(child, depth + 1))
-			};
-			case "blockquote": return {
-				...node,
-				children: node.children.map((child) => rewriteBlock(child, depth + 1))
-			};
-			case "list": return {
-				...node,
-				items: node.items.map((item) => rewriteItem(item, depth + 1))
-			};
-			case "table": return {
-				...node,
-				header: node.header.map((cell) => cell.map((inline) => rewriteInline(inline, depth + 1))),
-				rows: node.rows.map((row) => row.map((cell) => cell.map((inline) => rewriteInline(inline, depth + 1))))
-			};
+			case "emphasis":
+			case "codeSpan":
+			case "link":
+				if (isInlineNode(result)) accepted = result;
+				break;
+			case "heading":
+			case "paragraph":
+			case "list":
+			case "table":
 			case "codeBlock":
-			case "thematicBreak": return node;
+			case "blockquote":
+			case "thematicBreak":
+				if (isBlockNode(result)) accepted = result;
+				break;
+			case "listItem":
+				if (result.element === "listItem") accepted = result;
+				break;
 		}
+		values.push(accepted);
 	}
 	return {
 		element: "document",
-		children: document.children.map((child) => rewriteBlock(child, 0))
+		children: [...document.children]
 	};
 }
 /**
@@ -1417,26 +1869,55 @@ function rewriteDocument(document, rewrite) {
 * ```
 */
 function flattenText(node) {
-	function flatten(current, depth) {
-		if (depth >= 64) return "";
-		switch (current.element) {
-			case "text": return current.value;
-			case "codeSpan": return current.value;
-			case "codeBlock": return current.code;
+	const stack = [{
+		node,
+		depth: 0
+	}];
+	let value = "";
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame === void 0 || frame.depth >= 64) continue;
+		const children = [];
+		switch (frame.node.element) {
+			case "text":
+			case "codeSpan":
+				value += frame.node.value;
+				break;
+			case "codeBlock":
+				value += frame.node.code;
+				break;
 			case "document":
 			case "heading":
 			case "paragraph":
 			case "blockquote":
 			case "listItem":
 			case "emphasis":
-			case "link": return current.children.map((child) => flatten(child, depth + 1)).join("");
-			case "list": return current.items.map((item) => flatten(item, depth + 1)).join("");
-			case "table": return current.header.map((cell) => cell.map((inline) => flatten(inline, depth + 1)).join("")).join("") + current.rows.map((row) => row.map((cell) => cell.map((inline) => flatten(inline, depth + 1)).join("")).join("")).join("");
-			case "thematicBreak": return "";
-			default: return "";
+			case "link":
+				for (const child of frame.node.children) if (child !== void 0) children.push(child);
+				break;
+			case "list":
+				for (const child of frame.node.items) if (child !== void 0) children.push(child);
+				break;
+			case "table":
+				for (const cell of frame.node.header) if (cell !== void 0) {
+					for (const child of cell) if (child !== void 0) children.push(child);
+				}
+				for (const row of frame.node.rows) if (row !== void 0) {
+					for (const cell of row) if (cell !== void 0) {
+						for (const child of cell) if (child !== void 0) children.push(child);
+					}
+				}
+				break;
+		}
+		for (let index = children.length - 1; index >= 0; index -= 1) {
+			const child = children[index];
+			if (child !== void 0) stack.push({
+				node: child,
+				depth: frame.depth + 1
+			});
 		}
 	}
-	return flatten(node, 0);
+	return value;
 }
 //#endregion
 //#region src/core/parsers.ts
@@ -1595,6 +2076,51 @@ function collectList(lines, start, depth) {
 	const startOrdinal = first?.start ?? 1;
 	const topIndent = first?.indent ?? 0;
 	const items = [];
+	const chain = [];
+	let nested = true;
+	for (let cursor = start; cursor < lines.length; cursor += 1) {
+		const parsed = extractListItem(lines[cursor] ?? "");
+		const previous = chain[chain.length - 1];
+		if (parsed === void 0 || previous !== void 0 && (previous.content.length > 0 || parsed.indent !== previous.marker)) {
+			nested = false;
+			break;
+		}
+		chain.push(parsed);
+	}
+	const remaining = 64 - depth;
+	if (nested && remaining > 0 && chain.length > remaining) {
+		const terminal = chain[remaining - 1];
+		if (terminal !== void 0) {
+			const source = [terminal.content];
+			for (let cursor = start + remaining; cursor < lines.length; cursor += 1) source.push((lines[cursor] ?? "").slice(terminal.marker));
+			let children = [{
+				element: "paragraph",
+				children: [{
+					element: "text",
+					value: source.join("\n")
+				}]
+			}];
+			let node;
+			for (let cursor = remaining - 1; cursor >= 0; cursor -= 1) {
+				const parsed = chain[cursor];
+				if (parsed === void 0) continue;
+				node = {
+					element: "list",
+					ordered: parsed.ordered,
+					start: parsed.start,
+					items: [{
+						element: "listItem",
+						children
+					}]
+				};
+				children = [node];
+			}
+			if (node !== void 0) return {
+				node,
+				next: lines.length
+			};
+		}
+	}
 	let index = start;
 	while (index < lines.length) {
 		const parsed = extractListItem(lines[index] ?? "");
@@ -1877,7 +2403,12 @@ var Markdown = class Markdown {
 		let index = 0;
 		return new ReadableStream({ pull(controller) {
 			if (index < blocks.length) {
-				controller.enqueue(blocks[index]);
+				const block = blocks[index];
+				if (block === void 0) {
+					controller.close();
+					return;
+				}
+				controller.enqueue(block);
 				index += 1;
 			} else controller.close();
 		} });