@orkestrel/markdown 0.0.16 → 0.0.18

package/dist/src/core/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _orkestrel_contract = require("@orkestrel/contract");
 let _orkestrel_html = require("@orkestrel/html");
-//#region src/core/constants.ts
+// src/core/constants.ts
 /**
 * Caps the recursion depth the parse pipeline (`parseDocument` and its
 * `parsers.ts` helpers), the `helpers.ts` traversal / projection functions
@@ -29,8 +29,7 @@ var EMPTY_PROJECTION = Object.freeze({
 	cells: Object.freeze([]),
 	rows: Object.freeze([])
 });
-//#endregion
-//#region src/core/validators.ts
+// src/core/validators.ts
 /**
 * Determines whether a node is a heading block.
 *
@@ -359,8 +358,26 @@ var isMarkdownDocument = (0, _orkestrel_contract.recordOf)({
 	element: (0, _orkestrel_contract.literalOf)("document"),
 	children: (0, _orkestrel_contract.arrayOf)(isBlockNode)
 });
-//#endregion
-//#region src/core/parsers.ts
+// src/core/MarkdownLineIterator.ts
+/** Keeps a block parse's line cursor and its unconsumed lookahead. */
+var MarkdownLineIterator = class extends Iterator {
+	#indices;
+	#lookahead;
+	constructor(indices) {
+		super();
+		this.#indices = indices;
+		this.#lookahead = indices.next();
+	}
+	get value() {
+		return this.#lookahead.done ? void 0 : this.#lookahead.value;
+	}
+	next() {
+		const result = this.#lookahead;
+		if (!result.done) this.#lookahead = this.#indices.next();
+		return result;
+	}
+};
+// src/core/parsers.ts
 /**
 * Parses a run of markdown lines into a block AST, recursing into nested
 * blockquotes, list items, and depth-capped degrade paragraphs.
@@ -397,41 +414,39 @@ function parseBlocks(lines, depth, spans = /* @__PURE__ */ new Map(), end) {
 		return [paragraph];
 	}
 	const blocks = [];
-	let index = 0;
-	while (index < lines.length) {
+	const indices = new MarkdownLineIterator(lines.keys());
+	indices.reduce((index, step) => {
+		if (step < index) return index;
 		const line = text[index] ?? "";
-		if (isBlankLine(line)) {
-			index += 1;
-			continue;
-		}
+		if (isBlankLine(line)) return index + 1;
 		const fence = extractFence(line);
 		if (fence) {
 			const start = index;
 			const body = [];
-			let closed = false;
-			index += 1;
-			while (index < lines.length && !isFenceClose(text[index] ?? "", fence.marker)) {
-				const bodyLine = lines[index];
-				if (bodyLine !== void 0) body.push(bodyLine);
-				index += 1;
-			}
-			if (index < lines.length) {
-				closed = true;
-				index += 1;
+			for (const cursor of indices) {
+				const closed = isFenceClose(text[cursor] ?? "", fence.marker);
+				body.push([
+					cursor,
+					closed,
+					closed ? void 0 : lines[cursor]
+				]);
+				if (closed) break;
 			}
+			const closed = body.at(-1)?.[1] ?? false;
+			const next = (body.at(-1)?.[0] ?? index) + 1;
 			const node = {
 				element: "codeBlock",
 				...fence.lang === void 0 ? {} : { lang: fence.lang },
-				code: joinSources(body, "\n").text
+				code: joinSources(body.flatMap(([, , source]) => source === void 0 ? [] : [source]), "\n").text
 			};
-			const source = joinSources(lines.slice(start, index), "\n");
+			const source = joinSources(lines.slice(start, next), "\n");
 			const span = projectSpan(source, 0, source.text.length);
 			if (span !== void 0) spans.set(node, !closed && end !== void 0 ? {
 				start: span.start,
 				end
 			} : span);
 			blocks.push(node);
-			continue;
+			return next;
 		}
 		if (isThematicBreak(line)) {
 			const node = { element: "thematicBreak" };
@@ -439,8 +454,7 @@ function parseBlocks(lines, depth, spans = /* @__PURE__ */ new Map(), end) {
 			const span = source === void 0 ? void 0 : projectSpan(source, 0, source.text.length);
 			if (span !== void 0) spans.set(node, span);
 			blocks.push(node);
-			index += 1;
-			continue;
+			return index + 1;
 		}
 		const heading = extractHeading(line);
 		if (heading) {
@@ -457,57 +471,60 @@ function parseBlocks(lines, depth, spans = /* @__PURE__ */ new Map(), end) {
 			const span = source === void 0 ? void 0 : projectSpan(source, 0, source.text.length);
 			if (span !== void 0) spans.set(node, span);
 			blocks.push(node);
-			index += 1;
-			continue;
+			return index + 1;
 		}
 		if (isQuote(line)) {
 			const start = index;
-			const quoted = [];
-			while (index < lines.length && isQuote(text[index] ?? "")) {
-				const quotedLine = lines[index];
+			const first = lines[index];
+			const quoted = first === void 0 ? [] : [[index, stripQuote(first)]];
+			while (indices.value !== void 0 && isQuote(text[indices.value] ?? "")) {
+				const cursor = indices.next().value;
+				if (cursor === void 0) break;
+				const quotedLine = lines[cursor];
 				if (quotedLine === void 0) break;
-				quoted.push(stripQuote(quotedLine));
-				index += 1;
+				quoted.push([cursor, stripQuote(quotedLine)]);
 			}
-			const source = joinSources(lines.slice(start, index), "\n");
+			const next = quoted.length === 0 ? index : (quoted.at(-1)?.[0] ?? index) + 1;
+			const source = joinSources(lines.slice(start, next), "\n");
 			const span = projectSpan(source, 0, source.text.length);
 			const node = {
 				element: "blockquote",
-				children: parseBlocks(quoted, depth + 1, spans, index === lines.length && end !== void 0 ? end : span?.end)
+				children: parseBlocks(quoted.map(([, quotedLine]) => quotedLine), depth + 1, spans, next === lines.length && end !== void 0 ? end : span?.end)
 			};
 			if (span !== void 0) spans.set(node, span);
 			blocks.push(node);
-			continue;
+			return next;
 		}
 		if (isTableStart(line, text[index + 1])) {
 			const table = collectTable(lines, index, spans);
 			blocks.push(table.node);
-			index = table.next;
-			continue;
+			return table.next;
 		}
 		if (extractListItem(line)) {
 			const list = collectList(lines, index, depth, spans, end);
 			blocks.push(list.node);
-			index = list.next;
-			continue;
+			return list.next;
 		}
 		const start = index;
-		const paragraph = [];
-		while (index < lines.length && !isBlankLine(text[index] ?? "") && !((0, _orkestrel_contract.isNonEmptyArray)(paragraph) && startsBlock(text, index))) {
-			const paragraphLine = lines[index];
-			if (paragraphLine !== void 0) paragraph.push(paragraphLine);
-			index += 1;
+		const paragraph = [[index, lines[index]]];
+		while (indices.value !== void 0 && !isBlankLine(text[indices.value] ?? "") && !startsBlock(text, indices.value)) {
+			const cursor = indices.next().value;
+			if (cursor === void 0) break;
+			paragraph.push([cursor, lines[cursor]]);
 		}
-		const source = joinSources(paragraph.map((paragraphLine, position) => normalizeParagraphLine(paragraphLine, position < paragraph.length - 1)), "\n");
+		const next = paragraph.length === 0 ? index : (paragraph.at(-1)?.[0] ?? index) + 1;
+		const content = paragraph.flatMap(([, source]) => source === void 0 ? [] : [source]);
+		const source = joinSources(content.map((paragraphLine, position) => normalizeParagraphLine(paragraphLine, position < content.length - 1)), "\n");
 		const node = {
 			element: "paragraph",
 			children: coalesceText(scanInlineSource(source, 0, source.text.length, spans), spans)
 		};
-		const region = joinSources(lines.slice(start, index), "\n");
+		const region = joinSources(lines.slice(start, next), "\n");
 		const span = projectSpan(region, 0, region.text.length);
 		if (span !== void 0) spans.set(node, span);
 		blocks.push(node);
-	}
+		return next;
+	}, 0);
 	return blocks;
 }
 /**
@@ -534,6 +551,10 @@ function parseDocument(markdown) {
 * @param markdown - The markdown source to parse.
 * @returns The parsed document and its node-identity span map.
 *
+* @remarks
+* Parsing inserts into a scratch memo. The returned map contains only nodes of the
+* final document, enumerated without the public walk's depth cap.
+*
 * @example
 * ```ts
 * const [document, spans] = parseProvenance('# Hi')
@@ -541,16 +562,19 @@ function parseDocument(markdown) {
 * ```
 */
 function parseProvenance(markdown) {
-	const spans = /* @__PURE__ */ new Map();
+	const memo = /* @__PURE__ */ new Map();
 	const document = {
 		element: "document",
-		children: parseBlocks(splitLines(markdown), 0, spans, markdown.length)
+		children: parseBlocks(splitLines(markdown), 0, memo, markdown.length)
 	};
-	spans.set(document, {
+	memo.set(document, {
 		start: 0,
 		end: markdown.length
 	});
-	return [document, spans];
+	const nodes = [document];
+	for (const node of nodes) for (const child of listChildren(node)) nodes.push(child);
+	const present = new Set(nodes);
+	return [document, new Map([...memo].filter(([node]) => present.has(node)))];
 }
 /**
 * Parses inline markdown text (emphasis, code spans, links, images, and hard
@@ -568,8 +592,7 @@ function parseProvenance(markdown) {
 function parseInline(text) {
 	return coalesceText(scanInline(text, 0, text.length));
 }
-//#endregion
-//#region src/core/helpers.ts
+// src/core/helpers.ts
 /**
 * Splits a markdown document into offset-bearing lines while normalizing CRLF and
 * bare CR terminators at the line boundary. A single trailing terminator does not
@@ -584,36 +607,17 @@ function parseInline(text) {
 * ```
 */
 function splitLines(markdown) {
-	const lines = [];
-	let start = 0;
-	let index = 0;
-	while (index < markdown.length) {
-		const character = markdown[index];
-		if (character !== "\r" && character !== "\n") {
-			index += 1;
-			continue;
-		}
-		lines.push({
-			text: markdown.slice(start, index),
+	return Iterator.from(markdown.matchAll(/([^\r\n]*)(?:\r\n|\r|\n|$)/g)).filter((match) => match.index < markdown.length || markdown.length === 0).map((match) => {
+		const text = match[1] ?? "";
+		return {
+			text,
 			segments: [{
 				offset: 0,
-				start,
-				end: index
+				start: match.index,
+				end: match.index + text.length
 			}]
-		});
-		index += character === "\r" && markdown[index + 1] === "\n" ? 2 : 1;
-		start = index;
-	}
-	lines.push({
-		text: markdown.slice(start),
-		segments: [{
-			offset: 0,
-			start,
-			end: markdown.length
-		}]
-	});
-	if (lines.length > 1 && lines[lines.length - 1]?.text === "") lines.pop();
-	return lines;
+		};
+	}).toArray();
 }
 /**
 * Slices derived markdown text and narrows each intersecting source segment to the
@@ -633,24 +637,23 @@ function splitLines(markdown) {
 function sliceSource(source, from, to) {
 	const start = Math.max(0, Math.min(from, source.text.length));
 	const end = Math.max(start, Math.min(to, source.text.length));
-	const segments = [];
-	for (let index = 0; index < source.segments.length; index += 1) {
+	const segments = source.segments.keys().flatMap((index) => {
 		const segment = source.segments[index];
-		if (segment === void 0) continue;
+		if (segment === void 0) return [];
 		const next = source.segments[index + 1];
 		const limit = Math.min(segment.offset + (segment.end - segment.start), next === void 0 ? source.text.length : next.offset);
 		const overlapStart = Math.max(start, segment.offset);
 		const overlapEnd = Math.min(end, limit);
 		const empty = segment.offset === limit && overlapStart === segment.offset;
-		if (overlapStart >= overlapEnd && !empty) continue;
+		if (overlapStart >= overlapEnd && !empty) return [];
 		const originalStart = overlapStart === limit ? segment.end : Math.min(segment.end, segment.start + overlapStart - segment.offset);
 		const originalEnd = overlapEnd === limit ? segment.end : Math.min(segment.end, segment.start + overlapEnd - segment.offset);
-		segments.push({
+		return [{
 			offset: overlapStart - start,
 			start: originalStart,
 			end: originalEnd
-		});
-	}
+		}];
+	}).toArray();
 	return {
 		text: source.text.slice(start, end),
 		segments
@@ -671,31 +674,34 @@ function sliceSource(source, from, to) {
 * ```
 */
 function joinSources(sources, separator) {
-	let text = "";
+	const parts = [];
 	const segments = [];
-	for (let index = 0; index < sources.length; index += 1) {
+	sources.keys().reduce((offset, index) => {
 		const source = sources[index];
-		if (source === void 0) continue;
+		if (source === void 0) return offset;
 		if (index > 0) {
 			const previous = sources[index - 1];
 			const left = previous?.segments[previous.segments.length - 1];
 			const right = source.segments[0];
 			if (separator.length > 0 && left !== void 0 && right !== void 0 && left.end < right.start) segments.push({
-				offset: text.length,
+				offset,
 				start: left.end,
 				end: right.start
 			});
-			text += separator;
+			parts.push(separator);
 		}
+		const start = offset + (index > 0 ? separator.length : 0);
 		for (const segment of source.segments) segments.push({
-			offset: text.length + segment.offset,
+			offset: start + segment.offset,
 			start: segment.start,
 			end: segment.end
 		});
-		text += source.text;
-	}
+		const text = source.text;
+		parts.push(text);
+		return start + text.length;
+	}, 0);
 	return {
-		text,
+		text: parts.join(""),
 		segments
 	};
 }
@@ -716,27 +722,46 @@ function joinSources(sources, separator) {
 */
 function projectSpan(source, from, to) {
 	if (from < 0 || to < from || to > source.text.length) return void 0;
-	let start;
-	let end;
-	for (let index = 0; index < source.segments.length; index += 1) {
+	const [spanStart, spanEnd] = source.segments.keys().reduce(([start, end, found], index) => {
+		if (found) return [
+			start,
+			end,
+			found
+		];
 		const segment = source.segments[index];
-		if (segment === void 0) continue;
+		if (segment === void 0) return [
+			start,
+			end,
+			false
+		];
 		const next = source.segments[index + 1];
 		const limit = Math.min(segment.offset + (segment.end - segment.start), next === void 0 ? source.text.length : next.offset);
 		if (from === to && from >= segment.offset && from <= limit) {
-			if (next !== void 0 && from === next.offset) continue;
+			if (next !== void 0 && from === next.offset) return [
+				start,
+				end,
+				false
+			];
 			const position = from === limit ? segment.end : Math.min(segment.end, segment.start + from - segment.offset);
-			return {
-				start: position,
-				end: position
-			};
+			return [
+				position,
+				position,
+				true
+			];
 		}
-		if (start === void 0 && from >= segment.offset && from < limit) start = segment.start + from - segment.offset;
-		if (to > segment.offset && to <= limit) end = to === limit ? segment.end : Math.min(segment.end, segment.start + to - segment.offset);
-	}
-	return start === void 0 || end === void 0 ? void 0 : {
-		start,
-		end
+		return [
+			start === void 0 && from >= segment.offset && from < limit ? segment.start + from - segment.offset : start,
+			to > segment.offset && to <= limit ? to === limit ? segment.end : Math.min(segment.end, segment.start + to - segment.offset) : end,
+			false
+		];
+	}, [
+		void 0,
+		void 0,
+		false
+	]);
+	return spanStart === void 0 || spanEnd === void 0 ? void 0 : {
+		start: spanStart,
+		end: spanEnd
 	};
 }
 /**
@@ -797,10 +822,7 @@ function normalizeParagraphLine(source, breaks) {
 * ```
 */
 function countIndent(line) {
-	let count = 0;
-	for (const character of line) if (character === " " || character === "	") count += 1;
-	else break;
-	return count;
+	return line.match(/^[ \t]*/)?.[0].length ?? 0;
 }
 /**
 * Checks whether `character` is whitespace under the emphasis flanking rule — a space, a
@@ -880,16 +902,8 @@ function isQuote(line) {
 */
 function isFenceClose(line, marker) {
 	const character = marker[0] === "~" ? "~" : "`";
-	let index = 0;
-	while (index < line.length && isFenceWhitespace(line[index])) index++;
-	let run = 0;
-	while (index < line.length && line[index] === character) {
-		run++;
-		index++;
-	}
-	if (run < marker.length) return false;
-	while (index < line.length && isFenceWhitespace(line[index])) index++;
-	return index === line.length;
+	const trimmed = line.replace(/^[ \t\n\r\f\v]+|[ \t\n\r\f\v]+$/g, "");
+	return trimmed.length >= marker.length && Iterator.from(trimmed).every((value) => value === character);
 }
 /**
 * Checks whether `character` is a regex-`\s`-equivalent whitespace character — the
@@ -1095,12 +1109,11 @@ function splitTableRow(row) {
 function splitTableSources(row) {
 	const source = trimSource(row);
 	const cells = [];
-	let pieces = [];
-	let start = 0;
-	for (let index = 0; index < source.text.length; index += 1) {
-		const character = source.text[index];
-		if (character === "\\" && source.text[index + 1] === "|") {
-			pieces.push(sliceSource(source, start, index));
+	const pieces = [];
+	const [tailStart, tailOffset] = Iterator.from(source.text.matchAll(/\\\||\|/g)).reduce(([start, offset], match) => {
+		const index = match.index;
+		pieces.push(sliceSource(source, start, index));
+		if (match[0] === "\\|") {
 			const span = projectSpan(source, index, index + 2);
 			pieces.push({
 				text: "|",
@@ -1110,21 +1123,16 @@ function splitTableSources(row) {
 					end: span.end
 				}]
 			});
-			index += 1;
-			start = index + 1;
-			continue;
+			return [index + 2, offset];
 		}
-		if (character !== "|") continue;
-		pieces.push(sliceSource(source, start, index));
-		cells.push(joinSources(pieces, ""));
-		pieces = [];
-		start = index + 1;
-	}
-	pieces.push(sliceSource(source, start, source.text.length));
-	cells.push(joinSources(pieces, ""));
-	if ((0, _orkestrel_contract.isNonEmptyArray)(cells) && (0, _orkestrel_contract.isEmptyString)((cells[0]?.text ?? "").trim())) cells.shift();
-	if ((0, _orkestrel_contract.isNonEmptyArray)(cells) && (0, _orkestrel_contract.isEmptyString)((cells[cells.length - 1]?.text ?? "").trim())) cells.pop();
-	return cells;
+		cells.push(joinSources(pieces.slice(offset), ""));
+		return [index + 1, pieces.length];
+	}, [0, 0]);
+	pieces.push(sliceSource(source, tailStart, source.text.length));
+	cells.push(joinSources(pieces.slice(tailOffset), ""));
+	const first = (0, _orkestrel_contract.isEmptyString)((cells[0]?.text ?? "").trim()) ? 1 : 0;
+	const end = (0, _orkestrel_contract.isEmptyString)((cells.at(-1)?.text ?? "").trim()) ? cells.length - 1 : cells.length;
+	return cells.slice(first, end);
 }
 /**
 * Derives the per-column {@link TableAlign} list from a GFM delimiter row — `:---`
@@ -1183,22 +1191,15 @@ function startsBlock(lines, index) {
 * ```
 */
 function unescapeText(text) {
-	let out = "";
-	for (let index = 0; index < text.length; index += 1) {
-		const character = text[index] ?? "";
-		if (character === "\\" && isEscapable(text[index + 1] ?? "")) {
-			out += text[index + 1] ?? "";
-			index += 1;
-		} else out += character;
-	}
-	return out;
+	return text.replace(/\\([\s\S])/g, (match, character) => isEscapable(character) ? character : match);
 }
 /**
 * Merges adjacent text nodes into one — the inline scanner emits a text node per
 * unrecognized character, so coalescing keeps the AST clean and assertion-friendly.
 *
 * @param nodes - The inline nodes (possibly with adjacent text runs)
-* @param spans - The optional operation-owned node span recorder
+* @param spans - The optional operation-owned span memo; inserts merged-node entries
+*   without deleting or replacing constituent entries
 * @returns The nodes with consecutive text nodes concatenated
 *
 * @example
@@ -1208,28 +1209,53 @@ function unescapeText(text) {
 * ```
 */
 function coalesceText(nodes, spans) {
-	const out = [];
-	for (const node of nodes) {
-		const last = out[out.length - 1];
-		if (node.element === "text" && last !== void 0 && last.element === "text") {
-			const merged = {
+	const result = Iterator.from(nodes).reduce(({ first, last, value, complete, log }, node) => {
+		if (node.element === "text" && first?.element === "text") return {
+			first,
+			last: node,
+			value: (value ?? first.value) + node.value,
+			complete: complete && (spans?.has(node) ?? false),
+			log
+		};
+		if (first !== void 0) {
+			const merged = value === void 0 ? first : {
 				element: "text",
-				value: last.value + node.value
+				value
 			};
-			const left = spans?.get(last);
-			const right = spans?.get(node);
-			if (spans !== void 0) {
-				spans.delete(last);
-				spans.delete(node);
-				if (left !== void 0 && right !== void 0) spans.set(merged, {
-					start: left.start,
-					end: right.end
-				});
-			}
-			out[out.length - 1] = merged;
-		} else out.push(node);
-	}
-	return out;
+			const left = spans?.get(first);
+			const right = last === void 0 ? void 0 : spans?.get(last);
+			if (value !== void 0 && complete && left !== void 0 && right !== void 0) spans?.set(merged, {
+				start: left.start,
+				end: right.end
+			});
+			log.push(merged);
+		}
+		return {
+			first: node,
+			last: node,
+			value: void 0,
+			complete: spans?.has(node) ?? false,
+			log
+		};
+	}, {
+		first: void 0,
+		last: void 0,
+		value: void 0,
+		complete: false,
+		log: []
+	});
+	if (result.first === void 0) return result.log;
+	const merged = result.value === void 0 ? result.first : {
+		element: "text",
+		value: result.value
+	};
+	const left = spans?.get(result.first);
+	const right = result.last === void 0 ? void 0 : spans?.get(result.last);
+	if (result.value !== void 0 && result.complete && left !== void 0 && right !== void 0) spans?.set(merged, {
+		start: left.start,
+		end: right.end
+	});
+	return [...result.log, merged];
 }
 /**
 * Scans an inline code span at `start` (a `` ` ``-run … a matching `` ` ``-run of the
@@ -1248,23 +1274,26 @@ function coalesceText(nodes, spans) {
 * ```
 */
 function scanCode(source, start, to) {
-	let run = 0;
-	while (start + run < to && source[start + run] === "`") run += 1;
+	const run = source[start] === "`" ? countMarkdownRun(source, start, to) : 0;
 	const open = "`".repeat(run);
-	let search = start + run;
-	for (;;) {
+	const attempts = walkMarkdownCharacters(source, 0, source.length + 2);
+	const [, result] = attempts.reduce(([search]) => {
 		const closeAt = source.indexOf(open, search);
-		if (closeAt === -1 || closeAt + run > to) return void 0;
+		if (closeAt === -1 || closeAt + run > to) {
+			attempts.return(void 0);
+			return [search, void 0];
+		}
 		if (source[closeAt - 1] !== "`" && source[closeAt + run] !== "`") {
-			let value = source.slice(start + run, closeAt);
-			if (value.length > 2 && value.startsWith(" ") && value.endsWith(" ") && value.trim().length > 0) value = value.slice(1, -1);
-			return {
-				value,
+			attempts.return(void 0);
+			const raw = source.slice(start + run, closeAt);
+			return [search, {
+				value: raw.length > 2 && raw.startsWith(" ") && raw.endsWith(" ") && raw.trim().length > 0 ? raw.slice(1, -1) : raw,
 				end: closeAt + run
-			};
+			}];
 		}
-		search = closeAt + 1;
-	}
+		return [closeAt + 1, void 0];
+	}, [start + run, void 0]);
+	return result;
 }
 /**
 * Locates a link `[text](href)` at `start` — the text runs to a balanced `]`, then `(`
@@ -1283,45 +1312,12 @@ function scanCode(source, start, to) {
 * ```
 */
 function locateLink(source, start, to) {
-	let bracketDepth = 0;
-	let close = -1;
-	for (let index = start; index < to; index += 1) {
-		const character = source[index] ?? "";
-		if (character === "\\") {
-			index += 1;
-			continue;
-		}
-		if (character === "[") bracketDepth += 1;
-		else if (character === "]") {
-			bracketDepth -= 1;
-			if (bracketDepth === 0) {
-				close = index;
-				break;
-			}
-		}
-	}
-	if (close === -1 || source[close + 1] !== "(") return void 0;
-	let parenDepth = 0;
-	let parenClose = -1;
-	for (let index = close + 1; index < to; index += 1) {
-		const character = source[index] ?? "";
-		if (character === "\\") {
-			index += 1;
-			continue;
-		}
-		if (character === "(") parenDepth += 1;
-		else if (character === ")") {
-			parenDepth -= 1;
-			if (parenDepth === 0) {
-				parenClose = index;
-				break;
-			}
-		}
-	}
-	if (parenClose === -1) return void 0;
-	return {
+	const close = locateMarkdownDelimiter(source, start, to, "[", "]");
+	if (close === void 0 || source[close + 1] !== "(") return void 0;
+	const end = locateMarkdownDelimiter(source, close + 1, to, "(", ")");
+	return end === void 0 ? void 0 : {
 		close,
-		end: parenClose + 1
+		end: end + 1
 	};
 }
 /**
@@ -1377,44 +1373,38 @@ function scanLink(source, start, to, depth = 0) {
 */
 function locateEmphasis(source, start, to) {
 	const marker = source[start] ?? "";
-	let run = 0;
-	while (start + run < to && source[start + run] === marker && run < 2) run += 1;
+	const run = Math.min(2, countMarkdownRun(source, start, to));
 	const strong = run === 2;
 	const openEnd = start + run;
 	if (openEnd >= to || isFlankingWhitespace(source[openEnd] ?? "")) return void 0;
-	let index = openEnd;
-	while (index < to) {
-		const character = source[index] ?? "";
-		if (character === "\\") {
-			index += 2;
-			continue;
-		}
+	const characters = walkMarkdownCharacters(source, openEnd, to);
+	const [, result] = characters.reduce(([next], [index, character]) => {
+		if (index < next) return [next, void 0];
+		if (character === "\\") return [index + 2, void 0];
 		if (character === "`") {
 			const span = scanCode(source, index, to);
-			index = span ? span.end : index + 1;
-			continue;
+			return [span ? span.end : index + 1, void 0];
 		}
 		if ((character === "*" || character === "_") && character !== marker) {
 			const nested = locateEmphasis(source, index, to);
-			if (nested !== void 0) {
-				index = nested.end;
-				continue;
-			}
+			if (nested !== void 0) return [nested.end, void 0];
 		}
 		if (character === marker) {
-			let closeRun = 0;
-			while (index + closeRun < to && source[index + closeRun] === marker) closeRun += 1;
-			if (closeRun >= run && !isFlankingWhitespace(source[index - 1] ?? "")) return {
-				strong,
-				open: openEnd,
-				close: index,
-				end: index + run
-			};
-			index += closeRun;
-			continue;
+			const closeRun = countMarkdownRun(source, index, to);
+			if (closeRun >= run && !isFlankingWhitespace(source[index - 1] ?? "")) {
+				characters.return(void 0);
+				return [index + run, {
+					strong,
+					open: openEnd,
+					close: index,
+					end: index + run
+				}];
+			}
+			return [index + closeRun, void 0];
 		}
-		index += 1;
-	}
+		return [index + 1, void 0];
+	}, [openEnd, void 0]);
+	return result;
 }
 /**
 * Scans an emphasis run at `start` (`*` / `_`, doubled for strong) — finds the nearest
@@ -1518,116 +1508,45 @@ function scanInlineSource(source, from, to, spans, depth = 0) {
 		return [node];
 	} else return [];
 	const nodes = [];
-	let index = from;
-	let pending = "";
-	let pendingStart = from;
-	while (index < to) {
-		const character = source.text[index] ?? "";
+	const parts = [];
+	const [end, pendingStart, partOffset] = walkMarkdownCharacters(source.text, from, to).reduce(([next, start, offset], [index, character]) => {
+		if (index < next) return [
+			next,
+			start,
+			offset
+		];
 		if (character === "\\" && index + 1 < to && isEscapable(source.text[index + 1] ?? "")) {
-			if (pending.length === 0) pendingStart = index;
-			pending += source.text[index + 1] ?? "";
-			index += 2;
-			continue;
-		}
-		if (character === " ") {
-			let spaceEnd = index;
-			while (spaceEnd < to && source.text[spaceEnd] === " ") spaceEnd += 1;
-			if (spaceEnd - index >= 2 && source.text[spaceEnd] === "\n") {
-				if (pending.length > 0) {
-					const node = {
-						element: "text",
-						value: pending
-					};
-					const span = projectSpan(source, pendingStart, index);
-					if (span !== void 0) spans.set(node, span);
-					nodes.push(node);
-					pending = "";
-				}
-				const node = { element: "break" };
-				const span = projectSpan(source, index, spaceEnd + 1);
-				if (span !== void 0) spans.set(node, span);
-				nodes.push(node);
-				index = spaceEnd + 1;
-				pendingStart = index;
-				continue;
-			}
-		}
-		let scanned;
-		let end = index;
-		if (character === "`") {
-			const span = scanCode(source.text, index, to);
-			if (span) {
-				scanned = {
-					element: "codeSpan",
-					value: span.value
-				};
-				end = span.end;
-			}
-		}
-		if (character === "!" && source.text[index + 1] === "[") {
-			const link = locateLink(source.text, index + 1, to);
-			if (link !== void 0) {
-				scanned = {
-					element: "image",
-					src: unescapeText(source.text.slice(link.close + 2, link.end - 1).trim()),
-					children: coalesceText(scanInlineSource(source, index + 2, link.close, spans, depth + 1), spans)
-				};
-				end = link.end;
-			}
-		}
-		if (character === "[") {
-			const link = locateLink(source.text, index, to);
-			if (link !== void 0) {
-				scanned = {
-					element: "link",
-					href: unescapeText(source.text.slice(link.close + 2, link.end - 1).trim()),
-					children: coalesceText(scanInlineSource(source, index + 1, link.close, spans, depth + 1), spans)
-				};
-				end = link.end;
-			}
-		}
-		if (character === "*" || character === "_") {
-			const emphasis = locateEmphasis(source.text, index, to);
-			if (emphasis !== void 0) {
-				scanned = {
-					element: "emphasis",
-					strong: emphasis.strong,
-					children: coalesceText(scanInlineSource(source, emphasis.open, emphasis.close, spans, depth + 1), spans)
-				};
-				end = emphasis.end;
-			}
+			parts.push(source.text[index + 1] ?? "");
+			return [
+				index + 2,
+				start,
+				offset
+			];
 		}
+		const scanned = scanMarkdownInline(source, index, to, spans, depth);
 		if (scanned !== void 0) {
-			if (pending.length > 0) {
-				const node = {
-					element: "text",
-					value: pending
-				};
-				const span = projectSpan(source, pendingStart, index);
-				if (span !== void 0) spans.set(node, span);
-				nodes.push(node);
-				pending = "";
-			}
-			const span = projectSpan(source, index, end);
-			if (span !== void 0) spans.set(scanned, span);
-			nodes.push(scanned);
-			index = end;
-			pendingStart = index;
-			continue;
+			recordMarkdownText(source, parts.slice(offset).join(""), start, index, spans, nodes);
+			const span = projectSpan(source, index, scanned.end);
+			if (span !== void 0) spans.set(scanned.node, span);
+			nodes.push(scanned.node);
+			return [
+				scanned.end,
+				scanned.end,
+				parts.length
+			];
 		}
-		if (pending.length === 0) pendingStart = index;
-		pending += character;
-		index += 1;
-	}
-	if (pending.length > 0) {
-		const node = {
-			element: "text",
-			value: pending
-		};
-		const span = projectSpan(source, pendingStart, index);
-		if (span !== void 0) spans.set(node, span);
-		nodes.push(node);
-	}
+		parts.push(character);
+		return [
+			index + 1,
+			start,
+			offset
+		];
+	}, [
+		from,
+		from,
+		0
+	]);
+	recordMarkdownText(source, parts.slice(partOffset).join(""), pendingStart, end, spans, nodes);
 	return nodes;
 }
 /**
@@ -1655,30 +1574,28 @@ function collectTable(lines, start, spans = /* @__PURE__ */ new Map()) {
 		return coalesceText(scanInlineSource(source, 0, source.text.length, spans), spans);
 	});
 	const align = delimiterToAlignments(lines[start + 1]?.text ?? "");
-	const padded = [];
-	for (let column = 0; column < columns; column += 1) padded.push(align[column] ?? null);
-	const rows = [];
-	let index = start + 2;
-	while (index < lines.length && !isBlankLine(lines[index]?.text ?? "") && (lines[index]?.text ?? "").includes("|")) {
+	const padded = Array.from({ length: columns }, (_, column) => align[column] ?? null);
+	const entries = [];
+	for (const index of walkMarkdownLines(lines, start + 2)) {
+		if (isBlankLine(lines[index]?.text ?? "") || !(lines[index]?.text ?? "").includes("|")) break;
 		const cells = splitTableSources(lines[index] ?? {
 			text: "",
 			segments: []
 		});
-		const row = [];
-		for (let column = 0; column < columns; column += 1) {
+		const row = Array.from({ length: columns }, (_, column) => {
 			const source = trimSource(cells[column] ?? {
 				text: "",
 				segments: []
 			});
-			row.push(coalesceText(scanInlineSource(source, 0, source.text.length, spans), spans));
-		}
-		rows.push(row);
-		index += 1;
+			return coalesceText(scanInlineSource(source, 0, source.text.length, spans), spans);
+		});
+		entries.push([index, row]);
 	}
+	const index = entries.length === 0 ? start + 2 : (entries.at(-1)?.[0] ?? start + 1) + 1;
 	const node = {
 		element: "table",
 		header,
-		rows,
+		rows: entries.map(([, row]) => row),
 		align: padded
 	};
 	const source = joinSources(lines.slice(start, index), "\n");
@@ -1713,23 +1630,20 @@ function collectList(lines, start, depth, spans = /* @__PURE__ */ new Map(), end
 	const topIndent = first?.indent ?? 0;
 	const items = [];
 	const chain = [];
-	let nested = true;
-	for (let cursor = start; cursor < lines.length; cursor += 1) {
+	const nested = walkMarkdownLines(lines, start).every((cursor) => {
 		const parsed = extractListItem(text[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;
-		}
+		if (parsed === void 0 || previous !== void 0 && (previous.content.length > 0 || parsed.indent !== previous.marker)) return false;
 		chain.push(parsed);
-	}
+		return true;
+	});
 	const remaining = 64 - depth;
 	if (nested && remaining > 0 && chain.length > remaining) {
 		const terminal = chain[remaining - 1];
 		const terminalLine = lines[start + remaining - 1];
 		if (terminal !== void 0 && terminalLine !== void 0) {
 			const sources = [sliceSource(terminalLine, terminal.marker, terminalLine.text.length)];
-			for (let cursor = start + remaining; cursor < lines.length; cursor += 1) {
+			for (const cursor of walkMarkdownLines(lines, start + remaining)) {
 				const line = lines[cursor];
 				if (line !== void 0) sources.push(sliceSource(line, terminal.marker, line.text.length));
 			}
@@ -1747,16 +1661,16 @@ function collectList(lines, start, depth, spans = /* @__PURE__ */ new Map(), end
 				spans.set(textNode, residualSpan);
 				spans.set(paragraph, residualSpan);
 			}
-			let children = [paragraph];
-			let node;
-			for (let cursor = remaining - 1; cursor >= 0; cursor -= 1) {
+			const node = Array.from({ length: Math.ceil(remaining) }, (_, step) => step).reduce((child, step) => {
+				const cursor = remaining - 1 - step;
+				const children = child === void 0 ? [paragraph] : [child];
 				const parsed = chain[cursor];
-				if (parsed === void 0) continue;
+				if (parsed === void 0) return child;
 				const item = {
 					element: "listItem",
 					children
 				};
-				node = {
+				const parent = {
 					element: "list",
 					ordered: parsed.ordered,
 					start: parsed.start,
@@ -1766,72 +1680,78 @@ function collectList(lines, start, depth, spans = /* @__PURE__ */ new Map(), end
 				const span = projectSpan(region, 0, region.text.length);
 				if (span !== void 0) {
 					spans.set(item, span);
-					spans.set(node, span);
+					spans.set(parent, span);
 				}
-				children = [node];
-			}
+				return parent;
+			}, void 0);
 			if (node !== void 0) return {
 				node,
 				next: lines.length
 			};
 		}
 	}
-	let index = start;
-	while (index < lines.length) {
+	const positions = walkMarkdownLines(lines, start);
+	const finish = positions.reduce((index, position) => {
+		if (position < index) return index;
 		const parsed = extractListItem(text[index] ?? "");
-		if (!parsed || parsed.indent > topIndent || parsed.ordered !== ordered) break;
+		if (!parsed || parsed.indent > topIndent || parsed.ordered !== ordered) {
+			positions.return(void 0);
+			return index;
+		}
 		const itemStart = index;
 		const itemLine = lines[index];
-		if (itemLine === void 0) break;
-		const itemLines = [sliceSource(itemLine, parsed.marker, itemLine.text.length)];
+		if (itemLine === void 0) {
+			positions.return(void 0);
+			return index;
+		}
+		const entries = [[index, sliceSource(itemLine, parsed.marker, itemLine.text.length)]];
 		const continuation = parsed.marker;
-		index += 1;
-		while (index < lines.length) {
-			const nextSource = lines[index];
+		for (const cursor of walkMarkdownLines(lines, index + 1)) {
+			const nextSource = lines[cursor];
 			if (nextSource === void 0) break;
 			const next = nextSource.text;
 			if (isBlankLine(next)) {
-				const after = lines[index + 1]?.text ?? "";
-				if (index + 1 < lines.length && !isBlankLine(after) && countIndent(after) >= continuation) {
-					itemLines.push(sliceSource(nextSource, 0, 0));
-					index += 1;
+				const after = lines[cursor + 1]?.text ?? "";
+				if (cursor + 1 < lines.length && !isBlankLine(after) && countIndent(after) >= continuation) {
+					entries.push([cursor, sliceSource(nextSource, 0, 0)]);
 					continue;
 				}
 				break;
 			}
 			if (countIndent(next) >= continuation) {
-				itemLines.push(sliceSource(nextSource, continuation, next.length));
-				index += 1;
+				entries.push([cursor, sliceSource(nextSource, continuation, next.length)]);
 				continue;
 			}
-			if (extractListItem(next) || startsBlock(text, index)) break;
-			itemLines.push(trimSource(nextSource));
-			index += 1;
+			if (extractListItem(next) || startsBlock(text, cursor)) break;
+			entries.push([cursor, trimSource(nextSource)]);
 		}
+		const next = (entries.at(-1)?.[0] ?? index) + 1;
+		const itemLines = entries.map(([, line]) => line);
 		const tail = itemLines[itemLines.length - 1];
 		const segment = tail?.segments[tail.segments.length - 1];
-		const itemEnd = index === lines.length && end !== void 0 ? end : segment?.end;
+		const itemEnd = next === lines.length && end !== void 0 ? end : segment?.end;
 		const item = {
 			element: "listItem",
 			children: parseBlocks(itemLines, depth + 1, spans, itemEnd)
 		};
-		const source = joinSources(lines.slice(itemStart, index), "\n");
+		const source = joinSources(lines.slice(itemStart, next), "\n");
 		const span = projectSpan(source, 0, source.text.length);
 		if (span !== void 0) spans.set(item, span);
 		items.push(item);
-	}
+		return next;
+	}, start);
 	const node = {
 		element: "list",
 		ordered,
 		start: startOrdinal,
 		items
 	};
-	const source = joinSources(lines.slice(start, index), "\n");
+	const source = joinSources(lines.slice(start, finish), "\n");
 	const span = projectSpan(source, 0, source.text.length);
 	if (span !== void 0) spans.set(node, span);
 	return {
 		node,
-		next: index
+		next: finish
 	};
 }
 /**
@@ -1874,7 +1794,7 @@ function markdownToHTML(node) {
 				continue;
 			}
 			const children = [];
-			let depth = frame.depth;
+			const depth = frame.depth + (current.element === "document" ? 0 : current.element === "table" ? 4 : 1);
 			switch (current.element) {
 				case "document":
 					for (const child of current.children) if (child !== void 0) children.push(child);
@@ -1883,24 +1803,20 @@ function markdownToHTML(node) {
 				case "paragraph":
 				case "blockquote":
 					for (const child of current.children) if (child !== void 0) children.push(child);
-					depth += 1;
 					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);
-					depth += 1;
 					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);
-					depth += 1;
 					break;
 				case "table":
 					if (frame.depth + 4 > 64) {
@@ -1915,7 +1831,6 @@ function markdownToHTML(node) {
 							for (const child of cell) if (child !== void 0) children.push(child);
 						}
 					}
-					depth += 4;
 			}
 			if (current.element === "codeBlock" && frame.depth + 2 > 64) {
 				values.push(void 0);
@@ -1926,7 +1841,7 @@ function markdownToHTML(node) {
 				expanded: true,
 				count: children.length
 			});
-			for (let index = children.length - 1; index >= 0; index -= 1) {
+			for (const index of children.keys().toArray().toReversed()) {
 				const child = children[index];
 				if (child !== void 0) stack.push({
 					node: child,
@@ -1937,231 +1852,207 @@ function markdownToHTML(node) {
 			}
 			continue;
 		}
-		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
-		const projected = [];
-		for (const child of children) if (child !== void 0) projected.push(child);
-		let value;
-		switch (current.element) {
-			case "document":
-				value = {
-					category: "document",
-					children: projected
-				};
-				break;
-			case "heading":
-				value = {
-					category: "element",
-					name: `h${current.level}`,
-					attributes: [],
-					children: projected
-				};
-				break;
-			case "paragraph":
-				value = {
-					category: "element",
-					name: "p",
-					attributes: [],
-					children: projected
-				};
-				break;
-			case "thematicBreak":
-				value = {
-					category: "element",
-					name: "hr",
-					attributes: [],
-					children: []
-				};
-				break;
-			case "blockquote":
-				value = {
-					category: "element",
-					name: "blockquote",
-					attributes: [],
-					children: projected
-				};
-				break;
-			case "codeBlock":
-				value = {
-					category: "element",
-					name: "pre",
-					attributes: [],
-					children: [{
-						category: "element",
-						name: "code",
-						attributes: current.lang === void 0 ? [] : [{
-							name: "class",
-							value: `language-${current.lang}`
-						}],
-						children: [{
-							category: "text",
-							value: current.code
-						}]
-					}]
-				};
-				break;
-			case "list":
-				value = {
-					category: "element",
-					name: current.ordered ? "ol" : "ul",
-					attributes: current.ordered && current.start !== 1 ? [{
-						name: "start",
-						value: String(current.start)
-					}] : [],
-					children: projected
-				};
-				break;
-			case "listItem":
-				value = {
+		const value = projectMarkdownNode(current, frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count));
+		values.push(value);
+	}
+	const projected = values[0];
+	if (projected?.category === "document") return projected;
+	return {
+		category: "document",
+		children: projected === void 0 ? [] : [projected]
+	};
+}
+/**
+* Projects one markdown node from its already projected children.
+*
+* @example
+* ```ts
+* projectMarkdownNode({ element: 'text', value: 'hi' }, []) // { category: 'text', value: 'hi' }
+* ```
+*/
+function projectMarkdownNode(current, children) {
+	const projected = [];
+	for (const child of children) if (child !== void 0) projected.push(child);
+	switch (current.element) {
+		case "document": return {
+			category: "document",
+			children: projected
+		};
+		case "heading": return {
+			category: "element",
+			name: `h${current.level}`,
+			attributes: [],
+			children: projected
+		};
+		case "paragraph": return {
+			category: "element",
+			name: "p",
+			attributes: [],
+			children: projected
+		};
+		case "thematicBreak": return {
+			category: "element",
+			name: "hr",
+			attributes: [],
+			children: []
+		};
+		case "blockquote": return {
+			category: "element",
+			name: "blockquote",
+			attributes: [],
+			children: projected
+		};
+		case "codeBlock": return {
+			category: "element",
+			name: "pre",
+			attributes: [],
+			children: [{
+				category: "element",
+				name: "code",
+				attributes: current.lang === void 0 ? [] : [{
+					name: "class",
+					value: `language-${current.lang}`
+				}],
+				children: [{
+					category: "text",
+					value: current.code
+				}]
+			}]
+		};
+		case "list": return {
+			category: "element",
+			name: current.ordered ? "ol" : "ul",
+			attributes: current.ordered && current.start !== 1 ? [{
+				name: "start",
+				value: String(current.start)
+			}] : [],
+			children: projected
+		};
+		case "listItem": return {
+			category: "element",
+			name: "li",
+			attributes: [],
+			children: projected
+		};
+		case "table": {
+			const outputs = children.values();
+			const header = [];
+			for (const [column, cell] of current.header.entries()) {
+				if (cell === void 0) continue;
+				const align = current.align[column];
+				const attributes = align === "left" || align === "right" || align === "center" ? [{
+					name: "align",
+					value: align
+				}] : [];
+				const count = Iterator.from(cell).filter((child) => child !== void 0).reduce((sum) => sum + 1, 0);
+				const cellChildren = [];
+				for (const child of outputs.take(count).toArray()) if (child !== void 0) cellChildren.push(child);
+				header.push({
 					category: "element",
-					name: "li",
-					attributes: [],
-					children: projected
-				};
-				break;
-			case "table": {
-				let offset = 0;
-				const header = [];
-				for (const [column, cell] of current.header.entries()) {
+					name: "th",
+					attributes,
+					children: cellChildren
+				});
+			}
+			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 attributes = align === "left" || align === "right" || align === "center" ? [{
 						name: "align",
 						value: align
 					}] : [];
-					let count = 0;
-					for (const child of cell) if (child !== void 0) count += 1;
+					const count = Iterator.from(cell).filter((child) => child !== void 0).reduce((sum) => sum + 1, 0);
 					const cellChildren = [];
-					for (const child of children.slice(offset, offset + count)) if (child !== void 0) cellChildren.push(child);
-					header.push({
+					for (const child of outputs.take(count).toArray()) if (child !== void 0) cellChildren.push(child);
+					cells.push({
 						category: "element",
-						name: "th",
+						name: "td",
 						attributes,
 						children: cellChildren
 					});
-					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 attributes = align === "left" || align === "right" || align === "center" ? [{
-							name: "align",
-							value: align
-						}] : [];
-						let count = 0;
-						for (const child of cell) if (child !== void 0) count += 1;
-						const cellChildren = [];
-						for (const child of children.slice(offset, offset + count)) if (child !== void 0) cellChildren.push(child);
-						cells.push({
-							category: "element",
-							name: "td",
-							attributes,
-							children: cellChildren
-						});
-						offset += count;
-					}
-					rows.push({
-						category: "element",
-						name: "tr",
-						attributes: [],
-						children: cells
-					});
 				}
-				const tableChildren = [{
-					category: "element",
-					name: "thead",
-					attributes: [],
-					children: [{
-						category: "element",
-						name: "tr",
-						attributes: [],
-						children: header
-					}]
-				}];
-				if ((0, _orkestrel_contract.isNonEmptyArray)(current.rows)) tableChildren.push({
+				rows.push({
 					category: "element",
-					name: "tbody",
+					name: "tr",
 					attributes: [],
-					children: rows
+					children: cells
 				});
-				value = {
-					category: "element",
-					name: "table",
-					attributes: [],
-					children: tableChildren
-				};
-				break;
 			}
-			case "text":
-				value = {
-					category: "text",
-					value: current.value
-				};
-				break;
-			case "emphasis":
-				value = {
-					category: "element",
-					name: current.strong ? "strong" : "em",
-					attributes: [],
-					children: projected
-				};
-				break;
-			case "codeSpan":
-				value = {
-					category: "element",
-					name: "code",
-					attributes: [],
-					children: [{
-						category: "text",
-						value: current.value
-					}]
-				};
-				break;
-			case "link":
-				value = {
-					category: "element",
-					name: "a",
-					attributes: [{
-						name: "href",
-						value: current.href
-					}],
-					children: projected
-				};
-				break;
-			case "image":
-				value = {
-					category: "element",
-					name: "img",
-					attributes: [{
-						name: "src",
-						value: current.src
-					}, {
-						name: "alt",
-						value: flattenText(current)
-					}],
-					children: []
-				};
-				break;
-			case "break":
-				value = {
+			const tableChildren = [{
+				category: "element",
+				name: "thead",
+				attributes: [],
+				children: [{
 					category: "element",
-					name: "br",
+					name: "tr",
 					attributes: [],
-					children: []
-				};
-				break;
-			default: value = void 0;
+					children: header
+				}]
+			}];
+			if ((0, _orkestrel_contract.isNonEmptyArray)(current.rows)) tableChildren.push({
+				category: "element",
+				name: "tbody",
+				attributes: [],
+				children: rows
+			});
+			return {
+				category: "element",
+				name: "table",
+				attributes: [],
+				children: tableChildren
+			};
 		}
-		values.push(value);
+		case "text": return {
+			category: "text",
+			value: current.value
+		};
+		case "emphasis": return {
+			category: "element",
+			name: current.strong ? "strong" : "em",
+			attributes: [],
+			children: projected
+		};
+		case "codeSpan": return {
+			category: "element",
+			name: "code",
+			attributes: [],
+			children: [{
+				category: "text",
+				value: current.value
+			}]
+		};
+		case "link": return {
+			category: "element",
+			name: "a",
+			attributes: [{
+				name: "href",
+				value: current.href
+			}],
+			children: projected
+		};
+		case "image": return {
+			category: "element",
+			name: "img",
+			attributes: [{
+				name: "src",
+				value: current.src
+			}, {
+				name: "alt",
+				value: flattenText(current)
+			}],
+			children: []
+		};
+		case "break": return {
+			category: "element",
+			name: "br",
+			attributes: [],
+			children: []
+		};
+		default: return;
 	}
-	const projected = values[0];
-	if (projected?.category === "document") return projected;
-	return {
-		category: "document",
-		children: projected === void 0 ? [] : [projected]
-	};
 }
 /**
 * Renders a {@link MarkdownNode} to its canonical markdown source — the inverse
@@ -2200,7 +2091,7 @@ function renderMarkdown(node) {
 		count: 0,
 		escaped: "",
 		escapeBang: false,
-		nesting: 0
+		emphasis: 0
 	}];
 	const values = [];
 	while (stack.length > 0) {
@@ -2208,51 +2099,14 @@ function renderMarkdown(node) {
 		if (frame === void 0) continue;
 		const current = frame.node;
 		if (!frame.expanded) {
-			let escaped = "";
-			if ((frame.depth >= 64 || current.element === "text") && "value" in current && (0, _orkestrel_contract.isString)(current.value)) 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 (current.element === "text" && character === "!" && index === current.value.length - 1 && frame.escapeBang) {
-					escaped += "\\!";
-					continue;
-				}
-				if (character === "\\" || character === "*" || character === "_" || character === "`" || character === "[" || character === "]") {
-					escaped += `\\${character}`;
-					continue;
-				}
-				if (atLineStart) {
-					if (character === "#" || character === ">") {
-						escaped += `\\${character}`;
-						continue;
-					}
-					if ((character === "-" || character === "~") && current.value[index + 1] === character && current.value[index + 2] === 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;
-			}
+			const escaped = (frame.depth >= 64 || current.element === "text") && "value" in current && (0, _orkestrel_contract.isString)(current.value) ? escapeMarkdownText(current.value, current.element === "text" && frame.escapeBang) : "";
 			if (frame.depth >= 64) {
 				values.push(escaped);
 				continue;
 			}
 			const groups = [];
 			const adjacent = [];
-			let depth = frame.depth + 1;
+			const depth = frame.depth + (current.element === "table" ? 2 : 1);
 			switch (current.element) {
 				case "document":
 				case "blockquote":
@@ -2279,7 +2133,7 @@ function renderMarkdown(node) {
 					}
 					for (const row of current.rows) {
 						if (row === void 0) continue;
-						for (let column = 0; column < current.header.length; column += 1) {
+						for (const column of current.header.keys()) {
 							const cell = row[column];
 							if (cell !== void 0) {
 								groups.push(cell);
@@ -2287,26 +2141,17 @@ function renderMarkdown(node) {
 							}
 						}
 					}
-					depth += 1;
 			}
 			const children = [];
 			const escapeBangs = [];
-			for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+			for (const groupIndex of groups.keys()) {
 				const group = groups[groupIndex];
 				if (group === void 0) continue;
-				for (let position = 0; position < group.length; position += 1) {
-					const child = group[position];
+				const siblings = group.filter((child) => child !== void 0);
+				for (const position of siblings.keys()) {
+					const child = siblings[position];
 					if (child === void 0) continue;
-					let escapeBang = false;
-					if (adjacent[groupIndex] === true) {
-						let nextPosition = position + 1;
-						let next = group[nextPosition];
-						while (next === void 0 && nextPosition < group.length) {
-							nextPosition += 1;
-							next = group[nextPosition];
-						}
-						escapeBang = next?.element === "link";
-					}
+					const escapeBang = (adjacent[groupIndex] === true ? siblings[position + 1] : void 0)?.element === "link";
 					children.push(child);
 					escapeBangs.push(escapeBang);
 				}
@@ -2317,8 +2162,8 @@ function renderMarkdown(node) {
 				count: children.length,
 				escaped
 			});
-			const nesting = current.element === "emphasis" ? frame.nesting + 1 : frame.nesting;
-			for (let index = children.length - 1; index >= 0; index -= 1) {
+			const emphasis = current.element === "emphasis" ? frame.emphasis + 1 : frame.emphasis;
+			for (const index of children.keys().toArray().toReversed()) {
 				const child = children[index];
 				if (child !== void 0) stack.push({
 					node: child,
@@ -2327,136 +2172,112 @@ function renderMarkdown(node) {
 					count: 0,
 					escaped: "",
 					escapeBang: escapeBangs[index] === true && depth < 64,
-					nesting
+					emphasis
 				});
 			}
 			continue;
 		}
-		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
-		let value = "";
-		switch (current.element) {
-			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 value = renderMarkdownNode(current, frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count), frame.escaped, frame.emphasis);
+		if (stack.length === 0) return value;
+		values.push(value);
+	}
+	return "";
+}
+/**
+* Renders one markdown node from its rendered children and escaped literal text.
+*
+* @example
+* ```ts
+* renderMarkdownNode({ element: 'thematicBreak' }, [], '', 0) // '---'
+* ```
+*/
+function renderMarkdownNode(current, children, literal, emphasis) {
+	switch (current.element) {
+		case "codeBlock":
+		case "codeSpan": {
+			const body = current.element === "codeBlock" ? current.code : current.value;
+			const longest = Iterator.from(body.matchAll(/`+/g)).reduce((maximum, match) => Math.max(maximum, match[0].length), 0);
+			const fence = "`".repeat(Math.max(current.element === "codeBlock" ? 3 : 1, longest + 1));
+			if (current.element === "codeBlock") return `${fence}${current.lang === void 0 ? "" : current.lang}\n${current.code}\n${fence}`;
+			const pad = current.value.startsWith("`") || current.value.endsWith("`") ? " " : "";
+			return `${fence}${pad}${current.value}${pad}${fence}`;
+		}
+		case "break": return "  \n";
+		case "document": return children.join("\n\n");
+		case "heading": {
+			const escaped = children.join("").replace(/(^|[^\\])(#+)$/, (_match, before, hashes) => {
+				return `${before}\\${hashes[0] ?? ""}${hashes.slice(1)}`;
+			});
+			return `${"#".repeat(current.level)} ${escaped}`;
+		}
+		case "paragraph": return children.join("");
+		case "thematicBreak": return "---";
+		case "blockquote": return children.join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+		case "list": {
+			const items = [];
+			children.entries().reduce((ordinal, [position, body]) => {
+				const marker = current.ordered ? `${ordinal}. ` : "- ";
+				const pad = " ".repeat(marker.length);
+				if (current.items[position]?.children[0]?.element === "table") {
+					items.push(`${marker}\n${body.split("\n").map((line) => pad + line).join("\n")}`);
+					return ordinal + 1;
 				}
-				const pad = current.value.startsWith("`") || current.value.endsWith("`") ? " " : "";
-				value = `${fence}${pad}${current.value}${pad}${fence}`;
-				break;
-			}
-			case "break":
-				value = "  \n";
-				break;
-			case "document":
-				value = children.join("\n\n");
-				break;
-			case "heading": {
-				const escaped = children.join("").replace(/(^|[^\\])(#+)$/, (_match, before, hashes) => {
-					return `${before}\\${hashes[0] ?? ""}${hashes.slice(1)}`;
-				});
-				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;
-				for (const [position, body] of children.entries()) {
-					const marker = current.ordered ? `${ordinal}. ` : "- ";
-					ordinal += 1;
-					const pad = " ".repeat(marker.length);
-					if (current.items[position]?.children[0]?.element === "table") {
-						items.push(`${marker}\n${body.split("\n").map((line) => pad + line).join("\n")}`);
-						continue;
-					}
-					items.push(body.split("\n").map((line, index) => index === 0 ? marker + line : line === "" ? "" : pad + line).join("\n"));
+				items.push(body.split("\n").map((line, index) => index === 0 ? marker + line : line === "" ? "" : pad + line).join("\n"));
+				return ordinal + 1;
+			}, current.start);
+			return items.join("\n");
+		}
+		case "listItem": return children.join("\n\n");
+		case "table": {
+			const outputs = children.values();
+			const header = [];
+			for (const cell of current.header) {
+				if (cell === void 0) {
+					header.push("");
+					continue;
 				}
-				value = items.join("\n");
-				break;
+				const count = Iterator.from(cell).filter((child) => child !== void 0).reduce((sum) => sum + 1, 0);
+				header.push(outputs.take(count).toArray().join("").replace(/\|/g, "\\|"));
 			}
-			case "listItem":
-				value = children.join("\n\n");
-				break;
-			case "table": {
-				let offset = 0;
-				const header = [];
-				for (const cell of current.header) {
+			const delimiter = current.align.map((align) => {
+				if (align === null) return "---";
+				if (align === "left") return ":---";
+				if (align === "right") return "---:";
+				if (align === "center") return ":---:";
+				return "---";
+			});
+			const rows = [];
+			for (const row of current.rows) {
+				const cells = [];
+				for (const column of current.header.keys()) {
+					const cell = row[column];
 					if (cell === void 0) {
-						header.push("");
+						cells.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 === null) return "---";
-					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(" | ")} |`);
+					const count = Iterator.from(cell).filter((child) => child !== void 0).reduce((sum) => sum + 1, 0);
+					cells.push(outputs.take(count).toArray().join("").replace(/\|/g, "\\|"));
 				}
-				value = [
-					`| ${header.join(" | ")} |`,
-					`| ${delimiter.join(" | ")} |`,
-					...rows
-				].join("\n");
-				break;
-			}
-			case "text":
-				value = frame.escaped;
-				break;
-			case "emphasis": {
-				const marker = frame.nesting % 2 === 0 ? current.strong ? "**" : "*" : current.strong ? "__" : "_";
-				value = `${marker}${children.join("")}${marker}`;
-				break;
+				rows.push(`| ${cells.join(" | ")} |`);
 			}
-			case "link":
-			case "image": {
-				const escaped = (current.element === "link" ? current.href : current.src).replace(/[\\()]/g, (character) => `\\${character}`);
-				value = `${current.element === "image" ? "!" : ""}[${children.join("")}](${escaped})`;
-				break;
-			}
-			default: value = "";
+			return [
+				`| ${header.join(" | ")} |`,
+				`| ${delimiter.join(" | ")} |`,
+				...rows
+			].join("\n");
 		}
-		if (stack.length === 0) return value;
-		values.push(value);
+		case "text": return literal;
+		case "emphasis": {
+			const marker = emphasis % 2 === 0 ? current.strong ? "**" : "*" : current.strong ? "__" : "_";
+			return `${marker}${children.join("")}${marker}`;
+		}
+		case "link":
+		case "image": {
+			const escaped = (current.element === "link" ? current.href : current.src).replace(/[\\()]/g, (character) => `\\${character}`);
+			return `${current.element === "image" ? "!" : ""}[${children.join("")}](${escaped})`;
+		}
+		default: return "";
 	}
-	return "";
 }
 /**
 * Builds an HTML-to-markdown projection with absent fields defaulted from
@@ -2507,27 +2328,7 @@ function createProjection(parts = {}) {
 * ```
 */
 function trimInlines(nodes) {
-	const out = [];
-	for (const node of nodes) if (node !== void 0) out.push(node);
-	const first = out[0];
-	if (first !== void 0 && first.element === "text") {
-		const value = first.value.replace(/^\s+/, "");
-		if ((0, _orkestrel_contract.isEmptyString)(value)) out.shift();
-		else out[0] = {
-			element: "text",
-			value
-		};
-	}
-	const last = out[out.length - 1];
-	if (last !== void 0 && last.element === "text") {
-		const value = last.value.replace(/\s+$/, "");
-		if ((0, _orkestrel_contract.isEmptyString)(value)) out.pop();
-		else out[out.length - 1] = {
-			element: "text",
-			value
-		};
-	}
-	return out;
+	return trimTrailing(trimLeading(nodes));
 }
 /**
 * Reduces an inline run to the shape markdown can actually write back: adjacent text
@@ -2554,45 +2355,18 @@ function trimInlines(nodes) {
 * ```
 */
 function normalizeInlines(nodes, breaks) {
-	const spent = [];
-	for (const node of nodes) {
-		if (node === void 0) continue;
-		if (node.element === "break" && !breaks) spent.push({
-			element: "text",
-			value: " "
-		});
-		else spent.push(node);
-	}
-	const out = [];
-	for (const node of coalesceText(spent)) {
-		if (node === void 0) continue;
-		const previous = out[out.length - 1];
-		if (node.element === "text") {
-			const value = previous?.element === "break" ? node.value.replace(/^\s+/, "") : node.value;
-			if (!(0, _orkestrel_contract.isEmptyString)(value)) out.push({
-				element: "text",
-				value
-			});
-			continue;
-		}
-		if (node.element === "break") {
-			if (previous === void 0 || previous.element === "break") continue;
-			if (previous.element === "text") {
-				const value = previous.value.replace(/\s+$/, "");
-				if ((0, _orkestrel_contract.isEmptyString)(value)) out.pop();
-				else out[out.length - 1] = {
-					element: "text",
-					value
-				};
-			}
-			if (out.length === 0) continue;
-			out.push(node);
-			continue;
-		}
-		out.push(node);
-	}
-	while (out.length > 0 && out[out.length - 1]?.element === "break") out.pop();
-	return coalesceText(out);
+	const spent = coalesceText(Iterator.from(nodes).filter((node) => node !== void 0).map((node) => node.element === "break" && !breaks ? {
+		element: "text",
+		value: " "
+	} : node).toArray());
+	const starts = [0, ...spent.entries().flatMap(([index, node]) => node.element === "break" ? [index + 1] : [])];
+	const segments = starts.map((start, index) => {
+		const end = starts[index + 1];
+		const segment = spent.slice(start, end === void 0 ? spent.length : end - 1).filter((node) => node.element !== "text" || !(0, _orkestrel_contract.isEmptyString)(node.value));
+		return index < starts.length - 1 ? trimTrailing(segment) : segment;
+	});
+	const first = segments.findIndex((segment) => segment.length > 0);
+	return coalesceText(segments.map((segment, index) => index > first ? trimLeading(segment) : segment).filter((segment) => segment.length > 0).flatMap((segment, index) => index === 0 ? segment : [{ element: "break" }, ...segment]));
 }
 /**
 * Combines the projections of one node's children into the projection of that node —
@@ -2622,63 +2396,72 @@ function normalizeInlines(nodes, breaks) {
 */
 function mergeProjections(children) {
 	const blocks = [];
-	const cells = [];
-	const rows = [];
-	let pending = [];
-	let text = "";
-	for (const child of children) {
-		if (child === void 0) continue;
-		text += child.text;
+	const text = [];
+	const [tail, remainingCells, remainingRows] = Iterator.from(children).reduce(([pending, cells, rows], child) => {
+		if (child === void 0) return [
+			pending,
+			cells,
+			rows
+		];
+		text.push(child.text);
 		if ((0, _orkestrel_contract.isNonEmptyArray)(child.blocks)) {
 			const flushed = trimInlines(normalizeInlines(pending, true));
 			if ((0, _orkestrel_contract.isNonEmptyArray)(flushed)) blocks.push({
 				element: "paragraph",
 				children: flushed
 			});
-			pending = [];
 			for (const row of rows) for (const cell of row) if (cell !== void 0 && (0, _orkestrel_contract.isNonEmptyArray)(cell.inlines)) blocks.push({
 				element: "paragraph",
 				children: cell.inlines
 			});
-			rows.length = 0;
 			for (const cell of cells) if (cell !== void 0 && (0, _orkestrel_contract.isNonEmptyArray)(cell.inlines)) blocks.push({
 				element: "paragraph",
 				children: cell.inlines
 			});
-			cells.length = 0;
 			for (const block of projectionToBlocks(child)) blocks.push(block);
-			continue;
+			return [
+				[],
+				[],
+				[]
+			];
 		}
-		if ((0, _orkestrel_contract.isNonEmptyArray)(child.rows)) {
-			if ((0, _orkestrel_contract.isNonEmptyArray)(cells)) {
-				rows.push([...cells]);
-				cells.length = 0;
-			}
+		const rowed = (0, _orkestrel_contract.isNonEmptyArray)(child.rows);
+		if (rowed) {
+			if ((0, _orkestrel_contract.isNonEmptyArray)(cells)) rows.push(cells);
 			for (const row of child.rows) if (row !== void 0) rows.push(row);
 		}
-		for (const cell of child.cells) if (cell !== void 0) cells.push(cell);
+		const nextCells = rowed ? [] : cells;
+		for (const cell of child.cells) if (cell !== void 0) nextCells.push(cell);
 		for (const inline of child.inlines) if (inline !== void 0) pending.push(inline);
-	}
-	if ((0, _orkestrel_contract.isNonEmptyArray)(rows) && (0, _orkestrel_contract.isNonEmptyArray)(cells)) {
-		rows.push([...cells]);
-		cells.length = 0;
-	}
+		return [
+			pending,
+			nextCells,
+			rows
+		];
+	}, [
+		[],
+		[],
+		[]
+	]);
+	const rowed = (0, _orkestrel_contract.isNonEmptyArray)(remainingRows) && (0, _orkestrel_contract.isNonEmptyArray)(remainingCells);
+	const finalRows = rowed ? [...remainingRows, [...remainingCells]] : remainingRows;
+	const finalCells = rowed ? [] : remainingCells;
 	if (!(0, _orkestrel_contract.isNonEmptyArray)(blocks)) return createProjection({
-		inlines: coalesceText(pending),
-		text,
-		cells,
-		rows
+		inlines: coalesceText(tail),
+		text: text.join(""),
+		cells: finalCells,
+		rows: finalRows
 	});
-	const flushed = trimInlines(normalizeInlines(pending, true));
+	const flushed = trimInlines(normalizeInlines(tail, true));
 	if ((0, _orkestrel_contract.isNonEmptyArray)(flushed)) blocks.push({
 		element: "paragraph",
 		children: flushed
 	});
 	return createProjection({
 		blocks,
-		text,
-		cells,
-		rows
+		text: text.join(""),
+		cells: finalCells,
+		rows: finalRows
 	});
 }
 /**
@@ -2893,21 +2676,11 @@ function projectHTMLNode(node, children) {
 			});
 		}
 		case "pre": {
-			let position = -1;
-			for (const [index, child] of node.children.entries()) {
-				if (child?.category !== "element") continue;
-				position = index;
-				break;
-			}
-			const source = position === -1 ? void 0 : node.children[position];
-			const projected = position === -1 ? void 0 : children[position];
+			const position = node.children.entries().find(([, child]) => child?.category === "element")?.[0];
+			const source = position === void 0 ? void 0 : node.children[position];
+			const projected = position === void 0 ? void 0 : children[position];
 			if (source?.category === "element" && source.name === "code" && projected !== void 0) {
-				let lang;
-				for (const token of ((0, _orkestrel_html.attributeOf)(source, "class") ?? "").split(/\s+/)) {
-					if (!token.startsWith("language-") || token.length <= 9 || token.includes("`")) continue;
-					lang = token.slice(9);
-					break;
-				}
+				const lang = ((0, _orkestrel_html.attributeOf)(source, "class") ?? "").split(/\s+/).find((token) => token.startsWith("language-") && token.length > 9 && !token.includes("`"))?.slice(9);
 				return createProjection({
 					blocks: [{
 						element: "codeBlock",
@@ -3019,24 +2792,21 @@ function projectHTMLNode(node, children) {
 				if (source === void 0) continue;
 				if (source.index >= source.children.length) continue;
 				const child = source.children[source.index];
-				source.index += 1;
-				sources.push(source);
+				sources.push({
+					...source,
+					index: source.index + 1,
+					direct: child?.category === "element" ? child.name === "th" || child.name === "td" : source.direct
+				});
 				if (child?.category !== "element") continue;
 				if (child.name === "th" || child.name === "td") {
 					if (!source.direct) {
 						headings.push(false);
 						rowed.push(false);
 					}
-					source.direct = true;
 					continue;
 				}
-				source.direct = false;
 				if (child.name === "tr") {
-					let heading = false;
-					for (const cell of child.children) if (cell?.category === "element" && cell.name === "th") {
-						heading = true;
-						break;
-					}
+					const heading = Iterator.from(child.children).some((cell) => cell?.category === "element" && cell.name === "th");
 					headings.push(heading);
 					rowed.push(true);
 					continue;
@@ -3047,35 +2817,21 @@ function projectHTMLNode(node, children) {
 					direct: false
 				});
 			}
-			let position;
-			for (const [index, heading] of headings.entries()) {
-				if (!heading) continue;
-				position = index;
-				break;
-			}
-			if (position === void 0) for (const [index, structural] of rowed.entries()) {
-				if (!structural) continue;
-				position = index;
-				break;
-			}
+			const position = headings.entries().find(([, heading]) => heading)?.[0] ?? rowed.entries().find(([, structural]) => structural)?.[0];
 			const headerRow = position === void 0 ? void 0 : rows[position];
 			const columns = headerRow?.length ?? rows[0]?.length ?? 0;
 			if (columns === 0) return createProjection({
 				blocks: projectionToBlocks(merged),
 				text: merged.text
 			});
-			const header = [];
-			const align = [];
-			for (let column = 0; column < columns; column += 1) {
-				const cell = headerRow?.[column];
-				header.push(cell?.inlines ?? []);
-				align.push(cell?.align ?? null);
-			}
+			const headerCells = Array.from({ length: columns }, (_, column) => headerRow?.[column]);
+			const header = headerCells.map((cell) => cell?.inlines ?? []);
+			const align = headerCells.map((cell) => cell?.align ?? null);
 			const body = [];
 			for (const [index, row] of rows.entries()) {
 				if (row === void 0 || index === position) continue;
 				const cells = [];
-				for (let column = 0; column < header.length; column += 1) cells.push(row[column]?.inlines ?? []);
+				for (const column of header.keys()) cells.push(row[column]?.inlines ?? []);
 				body.push(cells);
 			}
 			return createProjection({
@@ -3176,32 +2932,8 @@ function* walkNodes(node) {
 		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":
-			case "blockquote":
-			case "listItem":
-			case "emphasis":
-			case "link":
-			case "image":
-				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);
-					}
-				}
-		}
-		for (let index = children.length - 1; index >= 0; index -= 1) {
+		const children = listChildren(frame.node);
+		for (const index of children.keys().toArray().toReversed()) {
 			const child = children[index];
 			if (child !== void 0) stack.push({
 				node: child,
@@ -3283,7 +3015,7 @@ function foldNode(node, handlers, depth) {
 				expanded: true,
 				count: children.length
 			});
-			for (let index = children.length - 1; index >= 0; index -= 1) {
+			for (const index of children.keys().toArray().toReversed()) {
 				const child = children[index];
 				if (child !== void 0) stack.push({
 					node: child,
@@ -3295,71 +3027,37 @@ function foldNode(node, handlers, depth) {
 			continue;
 		}
 		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":
-				value = handlers.emphasis(frame.node, children);
-				break;
-			case "codeSpan":
-				value = handlers.codeSpan(frame.node, children);
-				break;
-			case "break":
-				value = handlers.break(frame.node, children);
-				break;
-			case "link":
-				value = handlers.link(frame.node, children);
-				break;
-			case "image": value = handlers.image(frame.node, children);
-		}
+		const value = foldMarkdownNode(frame.node, handlers, children);
 		if (stack.length === 0) return value;
 		values.push(value);
 	}
+	return foldMarkdownNode(node, handlers, []);
+}
+/**
+* Dispatches one markdown node and its folded children to the matching handler.
+*
+* @example
+* ```ts
+* foldMarkdownNode({ element: 'text', value: 'hi' }, countHandlers, []) // 1
+* ```
+*/
+function foldMarkdownNode(node, handlers, children) {
 	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 "break": return handlers.break(node, []);
-		case "link": return handlers.link(node, []);
-		case "image": return handlers.image(node, []);
+		case "document": return handlers.document(node, children);
+		case "heading": return handlers.heading(node, children);
+		case "paragraph": return handlers.paragraph(node, children);
+		case "thematicBreak": return handlers.thematicBreak(node, children);
+		case "blockquote": return handlers.blockquote(node, children);
+		case "codeBlock": return handlers.codeBlock(node, children);
+		case "list": return handlers.list(node, children);
+		case "listItem": return handlers.listItem(node, children);
+		case "table": return handlers.table(node, children);
+		case "text": return handlers.text(node, children);
+		case "emphasis": return handlers.emphasis(node, children);
+		case "codeSpan": return handlers.codeSpan(node, children);
+		case "break": return handlers.break(node, children);
+		case "link": return handlers.link(node, children);
+		case "image": return handlers.image(node, children);
 	}
 }
 /**
@@ -3403,7 +3101,7 @@ function rewriteDocument(document, rewrite) {
 		count: 0
 	}];
 	const values = [];
-	const derivations = /* @__PURE__ */ new Map();
+	const derivations = [];
 	while (stack.length > 0) {
 		const frame = stack.pop();
 		if (frame === void 0) continue;
@@ -3444,7 +3142,7 @@ function rewriteDocument(document, rewrite) {
 				count: children.length
 			});
 			const depth = current.element === "document" ? 0 : frame.depth + 1;
-			for (let index = children.length - 1; index >= 0; index -= 1) {
+			for (const index of children.keys().toArray().toReversed()) {
 				const child = children[index];
 				if (child !== void 0) stack.push({
 					node: child,
@@ -3455,197 +3153,138 @@ function rewriteDocument(document, rewrite) {
 			}
 			continue;
 		}
-		const children = frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count);
-		let rebuilt = current;
-		let changed = false;
-		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];
-					const accepted = child !== void 0 && isBlockNode(child) ? child : block;
-					blocks.push(accepted);
-					if (accepted !== block) changed = true;
-					offset += 1;
-				}
-				if (changed) rebuilt = {
-					element: "document",
-					children: blocks
-				};
-				break;
-			}
-			case "heading":
-			case "paragraph": {
-				const inlines = [];
-				let offset = 0;
-				for (const inline of current.children) {
-					if (inline === void 0) continue;
-					const child = children[offset];
-					const accepted = child !== void 0 && isInlineNode(child) ? child : inline;
-					inlines.push(accepted);
-					if (accepted !== inline) changed = true;
-					offset += 1;
-				}
-				if (changed) 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];
-					const accepted = child !== void 0 && isBlockNode(child) ? child : block;
-					blocks.push(accepted);
-					if (accepted !== block) changed = true;
-					offset += 1;
-				}
-				if (changed) 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];
-					const accepted = child !== void 0 && isBlockNode(child) ? child : block;
-					blocks.push(accepted);
-					if (accepted !== block) changed = true;
-					offset += 1;
-				}
-				if (changed) rebuilt = {
-					element: "listItem",
-					children: blocks
-				};
-				break;
-			}
-			case "emphasis":
-			case "link":
-			case "image": {
-				const inlines = [];
-				let offset = 0;
-				for (const inline of current.children) {
-					if (inline === void 0) continue;
-					const child = children[offset];
-					const accepted = child !== void 0 && isInlineNode(child) ? child : inline;
-					inlines.push(accepted);
-					if (accepted !== inline) changed = true;
-					offset += 1;
-				}
-				if (changed) 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];
-					const accepted = child?.element === "listItem" ? child : item;
-					items.push(accepted);
-					if (accepted !== item) changed = true;
-					offset += 1;
-				}
-				if (changed) 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];
-						const accepted = child !== void 0 && isInlineNode(child) ? child : inline;
-						inlines.push(accepted);
-						if (accepted !== inline) changed = true;
-						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];
-							const accepted = child !== void 0 && isInlineNode(child) ? child : inline;
-							inlines.push(accepted);
-							if (accepted !== inline) changed = true;
-							offset += 1;
-						}
-						cells.push(inlines);
-					}
-					rows.push(cells);
-				}
-				if (changed) rebuilt = {
-					...current,
-					header,
-					rows
-				};
-				break;
-			}
-		}
-		if (rebuilt !== current) derivations.set(rebuilt, current);
+		const rebuilt = rebuildMarkdownNode(current, frame.count === 0 ? [] : values.splice(values.length - frame.count, frame.count));
+		if (rebuilt !== current) derivations.push([
+			rebuilt,
+			current,
+			true
+		]);
 		if (current.element === "document") {
 			const result = rebuilt.element === "document" ? rebuilt : current;
 			const output = new Set(walkNodes(result));
-			const retained = /* @__PURE__ */ new Map();
-			for (const [node, source] of derivations) if (output.has(node)) retained.set(node, source);
-			return [result, retained];
-		}
-		const result = rewrite(rebuilt);
-		let accepted = rebuilt;
-		switch (current.element) {
-			case "text":
-			case "emphasis":
-			case "codeSpan":
-			case "break":
-			case "link":
-			case "image":
-				if (isInlineNode(result)) accepted = result;
-				break;
-			case "heading":
-			case "paragraph":
-			case "list":
-			case "table":
-			case "codeBlock":
-			case "blockquote":
-			case "thematicBreak":
-				if (isBlockNode(result)) accepted = result;
-				break;
-			case "listItem": if (result.element === "listItem") accepted = result;
-		}
-		if (accepted !== rebuilt && accepted !== current) {
-			if (derivations.has(accepted) && derivations.get(accepted) !== current) derivations.set(accepted, void 0);
-			else derivations.set(accepted, current);
+			return [result, new Map(Map.groupBy(derivations, ([node]) => node).entries().filter(([node]) => output.has(node)).map(([node, steps]) => [node, steps.reduce((source, [, input, direct], index) => index === 0 || direct || source === input ? input : void 0, void 0)]))];
 		}
+		const accepted = acceptMarkdownNode(current, rebuilt, rewrite(rebuilt));
+		if (accepted !== rebuilt && accepted !== current) derivations.push([
+			accepted,
+			current,
+			false
+		]);
 		values.push(accepted);
 	}
 	return [document, /* @__PURE__ */ new Map()];
 }
 /**
+* Rebuilds one markdown node when accepted child replacements change its identity.
+*
+* @example
+* ```ts
+* const original: ParagraphNode = { element: 'paragraph', children: [] }
+* rebuildMarkdownNode(original, []) === original // true
+* ```
+*/
+function rebuildMarkdownNode(current, children) {
+	const outputs = children.values();
+	switch (current.element) {
+		case "document":
+		case "blockquote":
+		case "listItem": {
+			const pairs = Iterator.from(current.children).filter((child) => child !== void 0).map((block) => {
+				const child = outputs.next().value;
+				return [block, child !== void 0 && isBlockNode(child) ? child : block];
+			}).toArray();
+			if (!pairs.some(([input, output]) => input !== output)) return current;
+			const blocks = pairs.map(([, output]) => output);
+			return current.element === "blockquote" ? {
+				...current,
+				children: blocks
+			} : {
+				element: current.element,
+				children: blocks
+			};
+		}
+		case "heading":
+		case "paragraph":
+		case "emphasis":
+		case "link":
+		case "image": {
+			const pairs = Iterator.from(current.children).filter((child) => child !== void 0).map((inline) => {
+				const child = outputs.next().value;
+				return [inline, child !== void 0 && isInlineNode(child) ? child : inline];
+			}).toArray();
+			return pairs.some(([input, output]) => input !== output) ? {
+				...current,
+				children: pairs.map(([, output]) => output)
+			} : current;
+		}
+		case "list": {
+			const pairs = Iterator.from(current.items).filter((item) => item !== void 0).map((item) => {
+				const child = outputs.next().value;
+				return [item, child?.element === "listItem" ? child : item];
+			}).toArray();
+			return pairs.some(([input, output]) => input !== output) ? {
+				...current,
+				items: pairs.map(([, output]) => output)
+			} : current;
+		}
+		case "table": {
+			const pairs = [];
+			const header = Iterator.from(current.header).filter((cell) => cell !== void 0).map((cell) => rebuildMarkdownCell(cell, outputs, pairs)).toArray();
+			const rows = Iterator.from(current.rows).filter((row) => row !== void 0).map((row) => Iterator.from(row).filter((cell) => cell !== void 0).map((cell) => rebuildMarkdownCell(cell, outputs, pairs)).toArray()).toArray();
+			return pairs.some(([input, output]) => input !== output) ? {
+				...current,
+				header,
+				rows
+			} : current;
+		}
+	}
+	return current;
+}
+/**
+* Rebuilds a table cell and records each input and accepted output pair.
+*
+* @example
+* ```ts
+* rebuildMarkdownCell([], [].values(), []) // []
+* ```
+*/
+function rebuildMarkdownCell(cell, outputs, pairs) {
+	return Iterator.from(cell).filter((inline) => inline !== void 0).map((inline) => {
+		const child = outputs.next().value;
+		const accepted = child !== void 0 && isInlineNode(child) ? child : inline;
+		pairs.push([inline, accepted]);
+		return accepted;
+	}).toArray();
+}
+/**
+* Accepts a rewritten node only when it fits the original node slot.
+*
+* @example
+* ```ts
+* const original: TextNode = { element: 'text', value: 'hi' }
+* acceptMarkdownNode(original, original, { element: 'thematicBreak' }) === original // true
+* ```
+*/
+function acceptMarkdownNode(current, rebuilt, result) {
+	switch (current.element) {
+		case "text":
+		case "emphasis":
+		case "codeSpan":
+		case "break":
+		case "link":
+		case "image": return isInlineNode(result) ? result : rebuilt;
+		case "heading":
+		case "paragraph":
+		case "list":
+		case "table":
+		case "codeBlock":
+		case "blockquote":
+		case "thematicBreak": return isBlockNode(result) ? result : rebuilt;
+		case "listItem": return result.element === "listItem" ? result : rebuilt;
+	}
+	return rebuilt;
+}
+/**
 * Concatenates the `value` / `code` content of every descendant text / code-span /
 * code-block node under `node`, including image alternative content, in walk order —
 * the plain-text projection of an AST (search indexing, word counts, a text-only
@@ -3672,43 +3311,19 @@ function flattenText(node) {
 		node,
 		depth: 0
 	}];
-	let value = "";
+	const parts = [];
 	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;
+				parts.push(frame.node.value);
 				break;
-			case "document":
-			case "heading":
-			case "paragraph":
-			case "blockquote":
-			case "listItem":
-			case "emphasis":
-			case "link":
-			case "image":
-				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);
-					}
-				}
+			case "codeBlock": parts.push(frame.node.code);
 		}
-		for (let index = children.length - 1; index >= 0; index -= 1) {
+		const children = listChildren(frame.node);
+		for (const index of children.keys().toArray().toReversed()) {
 			const child = children[index];
 			if (child !== void 0) stack.push({
 				node: child,
@@ -3716,10 +3331,310 @@ function flattenText(node) {
 			});
 		}
 	}
-	return value;
+	return parts.join("");
+}
+/**
+* Yields UTF-16 offsets and characters within a markdown scan window.
+*
+* @example
+* ```ts
+* Array.from(walkMarkdownCharacters('ab', 0, 2)) // [[0, 'a'], [1, 'b']]
+* ```
+*/
+function* walkMarkdownCharacters(source, from, to) {
+	const positions = Array.prototype.keys.call({ length: Math.max(0, Math.ceil(to - from)) });
+	for (const position of positions) {
+		const index = from + position;
+		yield [index, source[index] ?? ""];
+	}
+}
+/**
+* Counts consecutive copies of the character at the start of a scan window.
+*
+* @example
+* ```ts
+* countMarkdownRun('***x', 0, 4) // 3
+* ```
+*/
+function countMarkdownRun(source, start, to) {
+	if (start >= to || source[start] === void 0) return 0;
+	return /^([\s\S])\1*/.exec(source.slice(start, Math.ceil(to)))?.[0].length ?? 0;
+}
+/**
+* Finds the next defined markdown node at or after an array offset.
+*
+* @example
+* ```ts
+* findFollowingNode([], 0) // undefined
+* ```
+*/
+function findFollowingNode(nodes, start) {
+	return nodes.keys().drop(start).map((index) => nodes[index]).find((node) => node !== void 0) ?? nodes[Math.max(start, nodes.length)];
+}
+/**
+* Escapes literal text so markdown syntax remains literal when rendered.
+*
+* @example
+* ```ts
+* escapeMarkdownText('*hi*', false) // '\\*hi\\*'
+* ```
+*/
+function escapeMarkdownText(value, bang) {
+	const parts = [];
+	walkMarkdownCharacters(value, 0, value.length).reduce((next, [index, character]) => {
+		if (index < next) return next;
+		const atLineStart = index === 0 || value[index - 1] === "\n";
+		if (character === "!" && index === value.length - 1 && bang) {
+			parts.push("\\!");
+			return index + 1;
+		}
+		if ("\\*_`[]".includes(character) || atLineStart && (character === "#" || character === ">") || atLineStart && (character === "-" || character === "~") && value[index + 1] === character && value[index + 2] === character || atLineStart && (character === "-" || character === "+") && (value[index + 1] ?? " ") === " ") {
+			parts.push("\\" + character);
+			return index + 1;
+		}
+		if (atLineStart && /[0-9]/.test(character)) {
+			const end = index + (/^[0-9]+/.exec(value.slice(index))?.[0].length ?? 0);
+			const marker = value[end];
+			if ((marker === "." || marker === ")") && value[end + 1] === " ") {
+				parts.push(value.slice(index, end) + "\\" + marker);
+				return end + 1;
+			}
+		}
+		parts.push(character);
+		return index + 1;
+	}, 0);
+	return parts.join("");
+}
+/**
+* Locates a balanced closing delimiter while skipping backslash escapes.
+*
+* @example
+* ```ts
+* locateMarkdownDelimiter('[a]', 0, 3, '[', ']') // 2
+* ```
+*/
+function locateMarkdownDelimiter(source, start, to, open, close) {
+	const characters = walkMarkdownCharacters(source, start, to);
+	const [, , result] = characters.reduce(([depth, next], [index, character]) => {
+		if (index < next) return [
+			depth,
+			next,
+			void 0
+		];
+		if (character === "\\") return [
+			depth,
+			index + 2,
+			void 0
+		];
+		if (character === open) return [
+			depth + 1,
+			index + 1,
+			void 0
+		];
+		if (character !== close) return [
+			depth,
+			index + 1,
+			void 0
+		];
+		if (depth === 1) {
+			characters.return(void 0);
+			return [
+				0,
+				index + 1,
+				index
+			];
+		}
+		return [
+			depth - 1,
+			index + 1,
+			void 0
+		];
+	}, [
+		0,
+		start,
+		void 0
+	]);
+	return result;
+}
+/**
+* Appends a nonempty text node and records its original source span.
+*
+* @example
+* ```ts
+* const nodes: InlineNode[] = []
+* recordMarkdownText({ text: 'a', segments: [] }, 'a', 0, 1, new Map(), nodes)
+* nodes // [{ element: 'text', value: 'a' }]
+* ```
+*/
+function recordMarkdownText(source, value, start, end, spans, nodes) {
+	if (value.length === 0) return;
+	const node = {
+		element: "text",
+		value
+	};
+	const span = projectSpan(source, start, end);
+	if (span !== void 0) spans.set(node, span);
+	nodes.push(node);
+}
+/**
+* Scans one inline construct and records the spans of its nested children.
+*
+* @example
+* ```ts
+* scanMarkdownInline({ text: '`x`', segments: [] }, 0, 3, new Map(), 0)?.end // 3
+* ```
+*/
+function scanMarkdownInline(source, index, to, spans, depth) {
+	const character = source.text[index] ?? "";
+	if (character === " ") {
+		const end = index + countMarkdownRun(source.text, index, to);
+		if (end - index >= 2 && source.text[end] === "\n") return {
+			node: { element: "break" },
+			end: end + 1
+		};
+	}
+	if (character === "`") {
+		const span = scanCode(source.text, index, to);
+		if (span) return {
+			node: {
+				element: "codeSpan",
+				value: span.value
+			},
+			end: span.end
+		};
+	}
+	if (character === "!" && source.text[index + 1] === "[") {
+		const link = locateLink(source.text, index + 1, to);
+		if (link !== void 0) return {
+			node: {
+				element: "image",
+				src: unescapeText(source.text.slice(link.close + 2, link.end - 1).trim()),
+				children: coalesceText(scanInlineSource(source, index + 2, link.close, spans, depth + 1), spans)
+			},
+			end: link.end
+		};
+	}
+	if (character === "[") {
+		const link = locateLink(source.text, index, to);
+		if (link !== void 0) return {
+			node: {
+				element: "link",
+				href: unescapeText(source.text.slice(link.close + 2, link.end - 1).trim()),
+				children: coalesceText(scanInlineSource(source, index + 1, link.close, spans, depth + 1), spans)
+			},
+			end: link.end
+		};
+	}
+	if (character === "*" || character === "_") {
+		const emphasis = locateEmphasis(source.text, index, to);
+		if (emphasis !== void 0) return {
+			node: {
+				element: "emphasis",
+				strong: emphasis.strong,
+				children: coalesceText(scanInlineSource(source, emphasis.open, emphasis.close, spans, depth + 1), spans)
+			},
+			end: emphasis.end
+		};
+	}
+}
+/**
+* Yields line offsets through a closable markdown scan iterator.
+*
+* @example
+* ```ts
+* Array.from(walkMarkdownLines(splitLines('a\nb'), 1)) // [1]
+* ```
+*/
+function* walkMarkdownLines(lines, start) {
+	const positions = Array.prototype.keys.call({ get length() {
+		return Math.max(0, Math.ceil(lines.length - start));
+	} });
+	for (const position of positions) yield start + position;
+}
+/**
+* Splits inline nodes into adjacent text runs and singleton non-text runs.
+*
+* @param nodes - The inline nodes in source order
+* @returns The runs with their original node identities
+*
+* @example
+* ```ts
+* splitTextRuns([{ element: 'text', value: 'a' }]).length // 1
+* ```
+*/
+function splitTextRuns(nodes) {
+	const starts = nodes.entries().flatMap(([index, node]) => index === 0 || node.element !== "text" || nodes[index - 1]?.element !== "text" ? [index] : []).toArray();
+	return starts.map((start, index) => nodes.slice(start, starts[index + 1]));
+}
+/**
+* Lists the direct children of a markdown node in traversal order.
+*
+* @param node - The node whose direct children to list
+* @returns The children, with table cells flattened in header then body order
+*
+* @example
+* ```ts
+* listChildren({ element: 'document', children: [] }) // []
+* ```
+*/
+function listChildren(node) {
+	switch (node.element) {
+		case "document":
+		case "heading":
+		case "paragraph":
+		case "blockquote":
+		case "listItem":
+		case "emphasis":
+		case "link":
+		case "image": return Iterator.from(node.children).filter((child) => child !== void 0).toArray();
+		case "list": return Iterator.from(node.items).filter((child) => child !== void 0).toArray();
+		case "table": return [...Iterator.from(node.header).filter((cell) => cell !== void 0).flatMap((cell) => Iterator.from(cell).filter((child) => child !== void 0)), ...Iterator.from(node.rows).filter((row) => row !== void 0).flatMap((row) => Iterator.from(row).filter((cell) => cell !== void 0)).flatMap((cell) => Iterator.from(cell).filter((child) => child !== void 0))];
+		default: return [];
+	}
+}
+/**
+* Trims leading whitespace when an inline run starts with a text node.
+*
+* @param nodes - The inline run to trim
+* @returns The run with its leading text trimmed or removed when empty
+*
+* @example
+* ```ts
+* trimLeading([{ element: 'text', value: ' a ' }]) // [{ element: 'text', value: 'a ' }]
+* ```
+*/
+function trimLeading(nodes) {
+	const present = Iterator.from(nodes).filter((node) => node !== void 0).toArray();
+	const first = present[0];
+	if (first?.element !== "text") return present;
+	const value = first.value.replace(/^\s+/, "");
+	return (0, _orkestrel_contract.isEmptyString)(value) ? present.slice(1) : [{
+		element: "text",
+		value
+	}, ...present.slice(1)];
+}
+/**
+* Trims trailing whitespace when an inline run ends with a text node.
+*
+* @param nodes - The inline run to trim
+* @returns The run with its trailing text trimmed or removed when empty
+*
+* @example
+* ```ts
+* trimTrailing([{ element: 'text', value: ' a ' }]) // [{ element: 'text', value: ' a' }]
+* ```
+*/
+function trimTrailing(nodes) {
+	const present = Iterator.from(nodes).filter((node) => node !== void 0).toArray();
+	const last = present.at(-1);
+	if (last?.element !== "text") return present;
+	const value = last.value.replace(/\s+$/, "");
+	return (0, _orkestrel_contract.isEmptyString)(value) ? present.slice(0, -1) : [...present.slice(0, -1), {
+		element: "text",
+		value
+	}];
 }
-//#endregion
-//#region src/core/compilers.ts
+// src/core/compilers.ts
 /**
 * Renders a {@link MarkdownNode} to sanitized canonical HTML.
 *
@@ -3745,8 +3660,7 @@ function flattenText(node) {
 function renderHTML(node) {
 	return (0, _orkestrel_html.renderHTML)(new _orkestrel_html.HTML(markdownToHTML(node)).sanitize({ attributes: [..._orkestrel_html.SAFE_ATTRIBUTES, "src"] }).document);
 }
-//#endregion
-//#region src/core/shapers.ts
+// src/core/shapers.ts
 /**
 * Describes the shape of a {@link TextNode} — a plain-text leaf inline run.
 *
@@ -3867,8 +3781,7 @@ var listItemMatchShape = (0, _orkestrel_contract.objectShape)({
 	indent: (0, _orkestrel_contract.integerShape)(),
 	marker: (0, _orkestrel_contract.integerShape)()
 });
-//#endregion
-//#region src/core/Markdown.ts
+// src/core/Markdown.ts
 /**
 * Wraps a typed {@link MarkdownDocument} AST as a stateful, parsed markdown document
 * with the query (`find` / `filter` / `reduce` / iteration), rewrite (`map`), fold, and
@@ -3974,9 +3887,7 @@ var Markdown = class Markdown {
 		for (const node of this.walk()) if (predicate(node)) return node;
 	}
 	filter(predicate) {
-		const out = [];
-		for (const node of this.walk()) if (predicate(node)) out.push(node);
-		return out;
+		return this.walk().filter((node) => predicate(node)).toArray();
 	}
 	/**
 	* Rewrites the AST bottom-up (copy-on-write) and returns a new {@link Markdown},
@@ -3993,9 +3904,7 @@ var Markdown = class Markdown {
 	}
 	/** Folds the AST depth-first, pre-order into an accumulator. */
 	reduce(callback, initial) {
-		let accumulator = initial;
-		for (const node of this.walk()) accumulator = callback(accumulator, node);
-		return accumulator;
+		return this.walk().reduce((accumulator, node) => callback(accumulator, node), initial);
 	}
 	/** Runs a total catamorphism over the document using a {@link MarkdownHandlerMap} table. */
 	fold(handlers) {
@@ -4012,7 +3921,9 @@ var Markdown = class Markdown {
 	* ```ts
 	* // universal - works in every ReadableStream-supporting environment
 	* const reader = markdown.stream().getReader()
-	* for (let result = await reader.read(); !result.done; result = await reader.read()) {
+	* for (;;) {
+	*   const result = await reader.read()
+	*   if (result.done) break
 	*   console.log(result.value) // one BlockNode
 	* }
 	*
@@ -4024,18 +3935,11 @@ var Markdown = class Markdown {
 	* ```
 	*/
 	stream() {
-		const blocks = this.#document.children;
-		let index = 0;
+		const blocks = this.#document.children.values();
 		return new ReadableStream({ pull(controller) {
-			if (index < blocks.length) {
-				const block = blocks[index];
-				if (block === void 0) {
-					controller.close();
-					return;
-				}
-				controller.enqueue(block);
-				index += 1;
-			} else controller.close();
+			const block = blocks.next();
+			if (!block.done && block.value !== void 0) controller.enqueue(block.value);
+			else controller.close();
 		} });
 	}
 	#derive(document, derivations) {
@@ -4054,8 +3958,7 @@ var Markdown = class Markdown {
 		return derived;
 	}
 };
-//#endregion
-//#region src/core/factories.ts
+// src/core/factories.ts
 /**
 * Creates a stateful markdown handle from a markdown string or an already-parsed
 * {@link MarkdownDocument} — a typed AST plus the query, rewrite, and fold operations
@@ -4173,16 +4076,17 @@ function createCodeBlockContract() {
 function createThematicBreakContract() {
 	return (0, _orkestrel_contract.createContract)(thematicBreakShape);
 }
-//#endregion
 exports.EMPTY_PROJECTION = EMPTY_PROJECTION;
 exports.MAX_DEPTH = MAX_DEPTH;
 exports.Markdown = Markdown;
+exports.acceptMarkdownNode = acceptMarkdownNode;
 exports.coalesceText = coalesceText;
 exports.codeBlockShape = codeBlockShape;
 exports.codeSpanShape = codeSpanShape;
 exports.collectList = collectList;
 exports.collectTable = collectTable;
 exports.countIndent = countIndent;
+exports.countMarkdownRun = countMarkdownRun;
 exports.createCodeBlockContract = createCodeBlockContract;
 exports.createCodeSpanContract = createCodeSpanContract;
 exports.createLineBreakContract = createLineBreakContract;
@@ -4191,10 +4095,13 @@ exports.createProjection = createProjection;
 exports.createTextContract = createTextContract;
 exports.createThematicBreakContract = createThematicBreakContract;
 exports.delimiterToAlignments = delimiterToAlignments;
+exports.escapeMarkdownText = escapeMarkdownText;
 exports.extractFence = extractFence;
 exports.extractHeading = extractHeading;
 exports.extractListItem = extractListItem;
+exports.findFollowingNode = findFollowingNode;
 exports.flattenText = flattenText;
+exports.foldMarkdownNode = foldMarkdownNode;
 exports.foldNode = foldNode;
 exports.htmlToMarkdown = htmlToMarkdown;
 exports.isBlankLine = isBlankLine;
@@ -4224,9 +4131,11 @@ exports.isThematicBreak = isThematicBreak;
 exports.isThematicBreakNode = isThematicBreakNode;
 exports.joinSources = joinSources;
 exports.lineBreakShape = lineBreakShape;
+exports.listChildren = listChildren;
 exports.listItemMatchShape = listItemMatchShape;
 exports.locateEmphasis = locateEmphasis;
 exports.locateLink = locateLink;
+exports.locateMarkdownDelimiter = locateMarkdownDelimiter;
 exports.markdownToHTML = markdownToHTML;
 exports.mergeProjections = mergeProjections;
 exports.normalizeInlines = normalizeInlines;
@@ -4237,29 +4146,40 @@ exports.parseInline = parseInline;
 exports.parseProvenance = parseProvenance;
 exports.projectHTMLLeaf = projectHTMLLeaf;
 exports.projectHTMLNode = projectHTMLNode;
+exports.projectMarkdownNode = projectMarkdownNode;
 exports.projectSpan = projectSpan;
 exports.projectionToBlocks = projectionToBlocks;
 exports.projectionToInlines = projectionToInlines;
+exports.rebuildMarkdownCell = rebuildMarkdownCell;
+exports.rebuildMarkdownNode = rebuildMarkdownNode;
+exports.recordMarkdownText = recordMarkdownText;
 exports.renderHTML = renderHTML;
 exports.renderMarkdown = renderMarkdown;
+exports.renderMarkdownNode = renderMarkdownNode;
 exports.rewriteDocument = rewriteDocument;
 exports.scanCode = scanCode;
 exports.scanEmphasis = scanEmphasis;
 exports.scanInline = scanInline;
 exports.scanInlineSource = scanInlineSource;
 exports.scanLink = scanLink;
+exports.scanMarkdownInline = scanMarkdownInline;
 exports.sliceSource = sliceSource;
 exports.splitLines = splitLines;
 exports.splitTableRow = splitTableRow;
 exports.splitTableSources = splitTableSources;
+exports.splitTextRuns = splitTextRuns;
 exports.startsBlock = startsBlock;
 exports.stripQuote = stripQuote;
 exports.tableAlignShape = tableAlignShape;
 exports.textShape = textShape;
 exports.thematicBreakShape = thematicBreakShape;
 exports.trimInlines = trimInlines;
+exports.trimLeading = trimLeading;
 exports.trimSource = trimSource;
+exports.trimTrailing = trimTrailing;
 exports.unescapeText = unescapeText;
+exports.walkMarkdownCharacters = walkMarkdownCharacters;
+exports.walkMarkdownLines = walkMarkdownLines;
 exports.walkNodes = walkNodes;
 
 //# sourceMappingURL=index.cjs.map